fix(web-shell): localize vision bridge notices

docs/design/web-shell-vision-bridge-notice-i18n.md

@@ -0,0 +1,23 @@
+# Web Shell Vision Bridge Notice Localization
+
+## Problem
+
+Vision Bridge status is emitted as an ordinary English assistant message. Web Shell receives no semantic data, so a Chinese locale cannot translate it.
+
+## Design
+
+Keep the English text as an ACP fallback for clients that do not understand Qwen metadata. Add a discrete `vision_bridge_notice` source with structured status, counts, model display name, endpoint, and egress state. Web Shell projects that event as a standalone system message and formats it through its existing locale catalog. Invalid or missing metadata falls back to the original text.
+
+Within a turn, the existing processed-step control hides the notice when collapsed and restores it when expanded.
+
+Message rewriting passes these notices through without adding them to the rewritten assistant response.
+
+Channel bridges continue forwarding the English fallback as ordinary response text.
+
+This change is limited to prompt-level Vision Bridge notices. TUI, headless, external ACP clients, tool-result notices, and voice notices retain their current behavior.
+
+## Verification
+
+- The cancelled prompt-level notice carries fallback text and structured metadata.
+- The Web Shell keeps the notice separate from adjacent assistant output.
+- Chinese renders localized text; malformed metadata renders the fallback.

packages/channels/base/src/AcpBridge.test.ts

@@ -588,6 +588,31 @@ describe('AcpBridge', () => {
     );
   });
 
+  it('emits discrete vision bridge notices as text chunks', () => {
+    const bridge = new AcpBridge({
+      cliEntryPath: '/tmp/qwen',
+      cwd: '/tmp',
+    }) as unknown as TestableAcpBridge;
+    const textChunks: Array<[string, string]> = [];
+    bridge.on('textChunk', (sessionId, text) => {
+      textChunks.push([sessionId, text]);
+    });
+
+    bridge.handleSessionUpdate({
+      sessionId: 's-1',
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Vision bridge cancelled.' },
+        _meta: {
+          source: 'vision_bridge_notice',
+          qwenDiscreteMessage: true,
+        },
+      },
+    });
+
+    expect(textChunks).toEqual([['s-1', 'Vision bridge cancelled.']]);
+  });
+
   it('emits a completed background response separately from the active turn', () => {
     const bridge = new AcpBridge({
       cliEntryPath: '/tmp/qwen',

packages/channels/base/src/AcpBridge.ts

@@ -403,6 +403,12 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
             content.text
           ) {
             this.emit('backgroundResponse', sessionId, content.text);
+          } else if (
+            meta['source'] === 'vision_bridge_notice' &&
+            content?.type === 'text' &&
+            content.text
+          ) {
+            this.emit('textChunk', sessionId, content.text);
           }
           break;
         }

packages/channels/base/src/DaemonChannelBridge.test.ts

@@ -761,6 +761,45 @@ describe('DaemonChannelBridge', () => {
     bridge.stop();
   });
 
+  it('emits discrete vision bridge notices as text chunks', async () => {
+    const events = new EventQueue();
+    const session = createFakeSession(events);
+    const bridge = new DaemonChannelBridge({
+      cwd: '/repo',
+      sessionFactory: vi.fn().mockResolvedValue(session),
+    });
+    const textChunks: Array<[string, string]> = [];
+    bridge.on('textChunk', (sessionId, text) => {
+      textChunks.push([sessionId, text]);
+    });
+
+    await bridge.start();
+    await bridge.newSession('/repo');
+    events.push({
+      id: 1,
+      v: 1,
+      type: 'session_update',
+      data: {
+        sessionId: 'session-1',
+        update: {
+          sessionUpdate: 'agent_message_chunk',
+          content: { type: 'text', text: 'Vision bridge cancelled.' },
+          _meta: {
+            source: 'vision_bridge_notice',
+            qwenDiscreteMessage: true,
+          },
+        },
+      },
+    });
+
+    await vi.waitFor(() => {
+      expect(textChunks).toEqual([['session-1', 'Vision bridge cancelled.']]);
+    });
+
+    events.close();
+    bridge.stop();
+  });
+
   it('ignores a rewritten background response to avoid duplicate delivery', async () => {
     const events = new EventQueue();
     const session = createFakeSession(events);

packages/channels/base/src/DaemonChannelBridge.ts

@@ -737,6 +737,8 @@ export class DaemonChannelBridge
             text
           ) {
             this.emit('backgroundResponse', sessionId, text);
+          } else if (meta['source'] === 'vision_bridge_notice' && text) {
+            this.emit('textChunk', sessionId, text);
           }
           break;
         }

packages/cli/src/acp-integration/session/Session.test.ts

@@ -8773,7 +8773,8 @@ describe('Session', () => {
         status: 'skipped',
         convertedCount: 0,
         omittedCount: 0,
-        modelId: 'qwen3.7-plus',
+        modelId: 'idealab:qwen3.7-plus',
+        modelEndpoint: 'idealab.alibaba-inc.com',
         egressOccurred: true,
       });
       mockChat.sendMessageStream = vi
@@ -8797,6 +8798,28 @@ describe('Session', () => {
       expect(
         textParts(sent).some((t: string) => t.includes('look at this')),
       ).toBe(true);
+      expect(mockClient.sessionUpdate).toHaveBeenCalledWith({
+        sessionId: 'test-session-id',
+        update: {
+          sessionUpdate: 'agent_message_chunk',
+          content: {
+            type: 'text',
+            text: 'Vision bridge cancelled. Your image and prompt/context were sent to qwen3.7-plus (idealab.alibaba-inc.com).',
+          },
+          _meta: {
+            source: 'vision_bridge_notice',
+            qwenDiscreteMessage: true,
+            visionBridgeNotice: {
+              status: 'skipped',
+              convertedCount: 0,
+              omittedCount: 0,
+              modelName: 'qwen3.7-plus',
+              modelEndpoint: 'idealab.alibaba-inc.com',
+              egressOccurred: true,
+            },
+          },
+        },
+      });
     });
 
     it('preserves oversized inline images for the vision bridge', async () => {

packages/cli/src/acp-integration/session/Session.ts

@@ -12424,8 +12424,9 @@ export class Session implements SessionContext {
 
     if (bridgeResult.status !== 'skipped' || bridgeResult.egressOccurred) {
       try {
-        await this.messageEmitter.emitAgentMessage(
+        await this.messageEmitter.emitVisionBridgeNotice(
           formatVisionBridgeNotice(bridgeResult),
+          bridgeResult,
         );
       } catch (error) {
         debugLogger.debug(

packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts

@@ -17,6 +17,7 @@ import {
   type GoalRecord,
   type GoalSnapshotV2,
   type GoalStateCause,
+  type VisionBridgeResult,
 } from '@qwen-code/qwen-code-core';
 import { BaseEmitter } from './base-emitter.js';
 import type { SessionUpdate } from '@agentclientprotocol/sdk';
@@ -202,6 +203,34 @@ export class MessageEmitter extends BaseEmitter {
     );
   }
 
+  async emitVisionBridgeNotice(
+    text: string,
+    result: VisionBridgeResult,
+  ): Promise<void> {
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: 'assistant',
+        text,
+        extra: {
+          source: 'vision_bridge_notice',
+          qwenDiscreteMessage: true,
+          visionBridgeNotice: {
+            status: result.status,
+            convertedCount: result.convertedCount,
+            omittedCount: result.omittedCount,
+            ...(result.modelId
+              ? { modelName: result.modelId.replace(/^[^:]+:/, '') }
+              : {}),
+            ...(result.modelEndpoint
+              ? { modelEndpoint: result.modelEndpoint }
+              : {}),
+            egressOccurred: result.egressOccurred === true,
+          },
+        },
+      }),
+    );
+  }
+
   async emitSlashCommandOutput(
     text: string,
     timestamp?: string | number,

packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts

@@ -112,6 +112,47 @@ describe('MessageRewriteMiddleware', () => {
       },
     );
 
+    it('does not rewrite vision bridge notices or carry their metadata', async () => {
+      const { middleware, mockSendUpdate } = createMiddleware('message');
+      const notice = {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Vision bridge cancelled.' },
+        _meta: {
+          source: 'vision_bridge_notice',
+          qwenDiscreteMessage: true,
+          visionBridgeNotice: { status: 'skipped' },
+        },
+      } as unknown as SessionUpdate;
+
+      await middleware.interceptUpdate(notice);
+      await middleware.interceptUpdate({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Normal model response.' },
+      } as unknown as SessionUpdate);
+      await middleware.flushTurn();
+      await middleware.waitForPendingRewrites();
+
+      expect(mockSendUpdate).toHaveBeenNthCalledWith(1, notice);
+      expect(mockSendUpdate).toHaveBeenNthCalledWith(3, {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'rewritten text' },
+        _meta: { rewritten: true, turnIndex: 1 },
+      });
+
+      const { LlmRewriter } = await import('./LlmRewriter.js');
+      const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as {
+        rewrite: ReturnType<typeof vi.fn>;
+      };
+      expect(rewriter.rewrite).toHaveBeenCalledWith(
+        {
+          thoughts: [],
+          messages: ['Normal model response.'],
+          hasToolCalls: false,
+        },
+        expect.any(AbortSignal),
+      );
+    });
+
     it('should accumulate messages when target is "message"', async () => {
       const { middleware, mockSendUpdate } = createMiddleware('message');
 

packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts

@@ -88,11 +88,12 @@ export class MessageRewriteMiddleware {
     // Always send original message as-is
     await this.sendUpdate(update);
 
+    const source = (
+      updateRecord['_meta'] as Record<string, unknown> | undefined
+    )?.['source'];
     if (
       updateType === 'agent_message_chunk' &&
-      (updateRecord['_meta'] as Record<string, unknown> | undefined)?.[
-        'source'
-      ] === 'slash_command'
+      (source === 'slash_command' || source === 'vision_bridge_notice')
     ) {
       return;
     }

packages/web-shell/client/adapters/transcriptToMessages.test.ts

@@ -356,6 +356,61 @@ describe('transcriptBlocksToDaemonMessages', () => {
     ]);
   });
 
+  it('keeps vision bridge notices separate from assistant output', () => {
+    const notice = {
+      status: 'skipped',
+      convertedCount: 0,
+      omittedCount: 0,
+      modelName: 'qwen3.6-plus',
+      modelEndpoint: 'idealab.alibaba-inc.com',
+      egressOccurred: true,
+    };
+    const messages = transcriptBlocksToDaemonMessages([
+      textBlock('assistant-0', 'assistant', 'Earlier reply', 0),
+      textBlock(
+        'vision-notice',
+        'assistant',
+        'Vision bridge cancelled.',
+        1,
+        false,
+        {
+          meta: {
+            source: 'vision_bridge_notice',
+            qwenDiscreteMessage: true,
+            visionBridgeNotice: notice,
+          },
+        },
+      ),
+      textBlock('assistant-1', 'assistant', 'Normal reply', 2),
+    ]);
+
+    expect(messages).toEqual([
+      {
+        id: 'assistant-0',
+        role: 'assistant',
+        content: 'Earlier reply',
+        isStreaming: false,
+        timestamp: 0,
+      },
+      {
+        id: 'vision-notice',
+        role: 'system',
+        content: 'Vision bridge cancelled.',
+        variant: 'info',
+        source: 'vision_bridge_notice',
+        data: notice,
+        timestamp: 1,
+      },
+      {
+        id: 'assistant-1',
+        role: 'assistant',
+        content: 'Normal reply',
+        isStreaming: false,
+        timestamp: 2,
+      },
+    ]);
+  });
+
   it.each([
     ['completed', 'completed'],
     ['failed', 'failed'],

packages/web-shell/client/adapters/transcriptToMessages.ts

@@ -522,6 +522,24 @@ export function transcriptBlocksToDaemonMessages(
           });
           break;
         }
+        const meta = getRecord(textBlock.meta);
+        if (meta?.['source'] === 'vision_bridge_notice') {
+          currentAssistantIdx = null;
+          currentThinkingIdx = null;
+          needsNewContentMessage = true;
+          messages.push({
+            id: block.id,
+            role: 'system',
+            content: textBlock.text,
+            variant: 'info',
+            source: 'vision_bridge_notice',
+            ...(meta['visionBridgeNotice'] !== undefined
+              ? { data: meta['visionBridgeNotice'] }
+              : {}),
+            timestamp: blockTime,
+          });
+          break;
+        }
         if (!textBlock.text && !textBlock.usage) break;
 
         const parentSubAgent = textBlock.parentToolCallId