chore(release): v0.4.1-nightly.20251211.a02c4b27

feat: VSCode Extension Implementation

.github/workflows/release-sdk.yml

@@ -132,6 +132,24 @@ jobs:
           OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
           OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
 
+      - name: 'Build CLI for Integration Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        run: |
+          npm run build
+          npm run bundle
+
+      - name: 'Run SDK Integration Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        run: |
+          npm run test:integration:sdk:sandbox:none
+          npm run test:integration:sdk:sandbox:docker
+        env:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+
       - name: 'Configure Git User'
         run: |
           git config user.name "github-actions[bot]"
@@ -184,7 +202,7 @@ jobs:
           registry-url: 'https://registry.npmjs.org'
           scope: '@qwen-code'
 
-      - name: 'Publish @qwen-code/sdk-typescript'
+      - name: 'Publish @qwen-code/sdk'
         working-directory: 'packages/sdk-typescript'
         run: |-
           npm publish --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}

README.md

@@ -88,6 +88,12 @@ npm install -g .
 brew install qwen-code
 ```
 
+## VS Code Extension
+
+In addition to the CLI tool, Qwen Code also provides a **VS Code extension** that brings AI-powered coding assistance directly into your editor with features like file system operations, native diffing, interactive chat, and more.
+
+> 📦 The extension is currently in development. For installation, features, and development guide, see the [VS Code Extension README](./packages/vscode-ide-companion/README.md).
+
 ## Quick Start
 
 ```bash

eslint.config.js

@@ -75,6 +75,8 @@ export default tseslint.config(
       },
     },
     rules: {
+      // We use TypeScript for React components; prop-types are unnecessary
+      'react/prop-types': 'off',
       // General Best Practice Rules (subset adapted for flat config)
       '@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
       'arrow-body-style': ['error', 'as-needed'],
@@ -111,10 +113,14 @@ export default tseslint.config(
         {
           allow: [
             'react-dom/test-utils',
+            'react-dom/client',
             'memfs/lib/volume.js',
             'yargs/**',
             'msw/node',
-            '**/generated/**'
+            '**/generated/**',
+            './styles/tailwind.css',
+            './styles/App.css',
+            './styles/style.css'
           ],
         },
       ],

integration-tests/sdk-typescript/abort-and-lifecycle.test.ts

@@ -13,7 +13,7 @@ import {
   isSDKAssistantMessage,
   type TextBlock,
   type ContentBlock,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
 
 const SHARED_TEST_OPTIONS = createSharedTestOptions();

integration-tests/sdk-typescript/configuration-options.test.ts

@@ -17,7 +17,7 @@ import {
   isSDKAssistantMessage,
   isSDKSystemMessage,
   type SDKMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   extractText,
@@ -532,7 +532,6 @@ describe('Configuration Options (E2E)', () => {
           cwd: testDir,
           authType: 'openai',
           debug: true,
-          logLevel: 'debug',
           stderr: (msg: string) => {
             stderrMessages.push(msg);
           },

integration-tests/sdk-typescript/mcp-server.test.ts

@@ -19,7 +19,7 @@ import {
   type SDKMessage,
   type ToolUseBlock,
   type SDKSystemMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   createMCPServer,

integration-tests/sdk-typescript/multi-turn.test.ts

@@ -21,7 +21,7 @@ import {
   type SDKMessage,
   type ControlMessage,
   type ToolUseBlock,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
 
 const SHARED_TEST_OPTIONS = createSharedTestOptions();

integration-tests/sdk-typescript/permission-control.test.ts

@@ -22,7 +22,7 @@ import {
   type SDKUserMessage,
   type ToolUseBlock,
   type ContentBlock,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   createSharedTestOptions,
@@ -555,6 +555,15 @@ describe('Permission Control (E2E)', () => {
           ...SHARED_TEST_OPTIONS,
           cwd: testDir,
           permissionMode: 'default',
+          timeout: {
+            /**
+             * We use a short control request timeout and
+             * wait till the time exceeded to test if
+             * an immediate close() will raise an query close
+             * error and no other uncaught timeout error
+             */
+            controlRequest: 5000,
+          },
         },
       });
 
@@ -563,7 +572,9 @@ describe('Permission Control (E2E)', () => {
       await expect(q.setPermissionMode('yolo')).rejects.toThrow(
         'Query is closed',
       );
-    });
+
+      await new Promise((resolve) => setTimeout(resolve, 8000));
+    }, 10_000);
   });
 
   describe('canUseTool and setPermissionMode integration', () => {
@@ -1184,7 +1195,7 @@ describe('Permission Control (E2E)', () => {
     });
 
     describe('mode comparison tests', () => {
-      it(
+      it.skip(
         'should demonstrate different behaviors across all modes for write operations',
         async () => {
           const modes: Array<'default' | 'auto-edit' | 'yolo'> = [

integration-tests/sdk-typescript/sdk-mcp-server.test.ts

@@ -0,0 +1,456 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * E2E tests for SDK-embedded MCP servers
+ *
+ * Tests that the SDK can create and manage MCP servers running in the SDK process
+ * using the tool() and createSdkMcpServer() APIs.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
+import {
+  query,
+  tool,
+  createSdkMcpServer,
+  isSDKAssistantMessage,
+  isSDKResultMessage,
+  isSDKSystemMessage,
+  type SDKMessage,
+  type SDKSystemMessage,
+} from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  extractText,
+  findToolUseBlocks,
+  createSharedTestOptions,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = {
+  ...createSharedTestOptions(),
+  permissionMode: 'yolo' as const,
+};
+
+describe('SDK MCP Server Integration (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('sdk-mcp-server-integration');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+
+  describe('Basic SDK MCP Tool Usage', () => {
+    it('should use SDK MCP tool to perform a simple calculation', async () => {
+      // Define a simple calculator tool using the tool() API with Zod schema
+      const calculatorTool = tool(
+        'calculate_sum',
+        'Calculate the sum of two numbers',
+        z.object({
+          a: z.number().describe('First number'),
+          b: z.number().describe('Second number'),
+        }).shape,
+        async (args) => ({
+          content: [{ type: 'text', text: String(args.a + args.b) }],
+        }),
+      );
+
+      // Create SDK MCP server with the tool
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-calculator',
+        version: '1.0.0',
+        tools: [calculatorTool],
+      });
+
+      const q = query({
+        prompt:
+          'Use the calculate_sum tool to add 25 and 17. Output the result of tool only.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          mcpServers: {
+            'sdk-calculator': serverConfig,
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+      let foundToolUse = false;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message, 'calculate_sum');
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate tool was called
+        expect(foundToolUse).toBe(true);
+
+        // Validate result contains expected answer: 25 + 17 = 42
+        expect(assistantText).toMatch(/42/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+        if (isSDKResultMessage(lastMessage)) {
+          expect(lastMessage.subtype).toBe('success');
+        }
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should use SDK MCP tool with string operations', async () => {
+      // Define a string manipulation tool with Zod schema
+      const stringTool = tool(
+        'reverse_string',
+        'Reverse a string',
+        {
+          text: z.string().describe('The text to reverse'),
+        },
+        async (args) => ({
+          content: [
+            { type: 'text', text: args.text.split('').reverse().join('') },
+          ],
+        }),
+      );
+
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-string-utils',
+        version: '1.0.0',
+        tools: [stringTool],
+      });
+
+      const q = query({
+        prompt: `Use the 'reverse_string' tool to process the word "hello world". Output the tool result only.`,
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          mcpServers: {
+            'sdk-string-utils': serverConfig,
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+      let foundToolUse = false;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message, 'reverse_string');
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate tool was called
+        expect(foundToolUse).toBe(true);
+
+        // Validate result contains reversed string: "olleh"
+        expect(assistantText.toLowerCase()).toMatch(/olleh/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Multiple SDK MCP Tools', () => {
+    it('should use multiple tools from the same SDK MCP server', async () => {
+      // Define the Zod schema shape for two numbers
+      const twoNumbersSchema = {
+        a: z.number().describe('First number'),
+        b: z.number().describe('Second number'),
+      };
+
+      // Define multiple tools
+      const addTool = tool(
+        'sdk_add',
+        'Add two numbers',
+        twoNumbersSchema,
+        async (args) => ({
+          content: [{ type: 'text', text: String(args.a + args.b) }],
+        }),
+      );
+
+      const multiplyTool = tool(
+        'sdk_multiply',
+        'Multiply two numbers',
+        twoNumbersSchema,
+        async (args) => ({
+          content: [{ type: 'text', text: String(args.a * args.b) }],
+        }),
+      );
+
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-math',
+        version: '1.0.0',
+        tools: [addTool, multiplyTool],
+      });
+
+      const q = query({
+        prompt:
+          'First use sdk_add to calculate 10 + 5, then use sdk_multiply to multiply the result by 3. Give me the final answer.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'sdk-math': serverConfig,
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+      const toolCalls: string[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message);
+            toolUseBlocks.forEach((block) => {
+              toolCalls.push(block.name);
+            });
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate both tools were called
+        expect(toolCalls).toContain('sdk_add');
+        expect(toolCalls).toContain('sdk_multiply');
+
+        // Validate result: (10 + 5) * 3 = 45
+        expect(assistantText).toMatch(/45/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('SDK MCP Server Discovery', () => {
+    it('should list SDK MCP servers in system init message', async () => {
+      // Define echo tool with Zod schema
+      const echoTool = tool(
+        'echo',
+        'Echo a message',
+        {
+          message: z.string().describe('Message to echo'),
+        },
+        async (args) => ({
+          content: [{ type: 'text', text: args.message }],
+        }),
+      );
+
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-echo',
+        version: '1.0.0',
+        tools: [echoTool],
+      });
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'sdk-echo': serverConfig,
+          },
+        },
+      });
+
+      let systemMessage: SDKSystemMessage | null = null;
+
+      try {
+        for await (const message of q) {
+          if (isSDKSystemMessage(message) && message.subtype === 'init') {
+            systemMessage = message;
+            break;
+          }
+        }
+
+        // Validate MCP server is listed
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.mcp_servers).toBeDefined();
+        expect(Array.isArray(systemMessage!.mcp_servers)).toBe(true);
+
+        // Find our SDK MCP server
+        const sdkServer = systemMessage!.mcp_servers?.find(
+          (server) => server.name === 'sdk-echo',
+        );
+        expect(sdkServer).toBeDefined();
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('SDK MCP Tool Error Handling', () => {
+    it('should handle tool errors gracefully', async () => {
+      // Define a tool that throws an error with Zod schema
+      const errorTool = tool(
+        'maybe_fail',
+        'A tool that may fail based on input',
+        {
+          shouldFail: z.boolean().describe('If true, the tool will fail'),
+        },
+        async (args) => {
+          if (args.shouldFail) {
+            throw new Error('Tool intentionally failed');
+          }
+          return { content: [{ type: 'text', text: 'Success!' }] };
+        },
+      );
+
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-error-test',
+        version: '1.0.0',
+        tools: [errorTool],
+      });
+
+      const q = query({
+        prompt:
+          'Use the maybe_fail tool with shouldFail set to true. Tell me what happens.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'sdk-error-test': serverConfig,
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let foundToolUse = false;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message, 'maybe_fail');
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+          }
+        }
+
+        // Tool should be called
+        expect(foundToolUse).toBe(true);
+
+        // Query should complete (even with tool error)
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Async Tool Handlers', () => {
+    it('should handle async tool handlers with delays', async () => {
+      // Define a tool with async delay using Zod schema
+      const delayedTool = tool(
+        'delayed_response',
+        'Returns a value after a delay',
+        {
+          delay: z.number().describe('Delay in milliseconds (max 100)'),
+          value: z.string().describe('Value to return'),
+        },
+        async (args) => {
+          // Cap delay at 100ms for test performance
+          const actualDelay = Math.min(args.delay, 100);
+          await new Promise((resolve) => setTimeout(resolve, actualDelay));
+          return {
+            content: [{ type: 'text', text: `Delayed result: ${args.value}` }],
+          };
+        },
+      );
+
+      const serverConfig = createSdkMcpServer({
+        name: 'sdk-async',
+        version: '1.0.0',
+        tools: [delayedTool],
+      });
+
+      const q = query({
+        prompt:
+          'Use the delayed_response tool with delay=50 and value="test_async". Tell me the result.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'sdk-async': serverConfig,
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+      let foundToolUse = false;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(
+              message,
+              'delayed_response',
+            );
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate tool was called
+        expect(foundToolUse).toBe(true);
+
+        // Validate result contains the delayed response
+        expect(assistantText.toLowerCase()).toMatch(/test_async/i);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+});

integration-tests/sdk-typescript/single-turn.test.ts

@@ -13,7 +13,7 @@ import {
   type SDKMessage,
   type SDKSystemMessage,
   type SDKAssistantMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   extractText,
@@ -44,7 +44,6 @@ describe('Single-Turn Query (E2E)', () => {
           ...SHARED_TEST_OPTIONS,
           cwd: testDir,
           debug: true,
-          logLevel: 'debug',
         },
       });
 

integration-tests/sdk-typescript/subagents.test.ts

@@ -17,7 +17,7 @@ import {
   type SubagentConfig,
   type ContentBlock,
   type ToolUseBlock,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   extractText,

integration-tests/sdk-typescript/system-control.test.ts

@@ -9,7 +9,7 @@ import {
   isSDKAssistantMessage,
   isSDKSystemMessage,
   type SDKUserMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
 
 const SHARED_TEST_OPTIONS = createSharedTestOptions();

integration-tests/sdk-typescript/test-helper.ts

@@ -21,12 +21,12 @@ import type {
   ContentBlock,
   TextBlock,
   ToolUseBlock,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 import {
   isSDKAssistantMessage,
   isSDKSystemMessage,
   isSDKResultMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 
 // ============================================================================
 // Core Test Helper Class

integration-tests/sdk-typescript/tool-control.test.ts

@@ -12,11 +12,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  type SDKMessage,
-} from '@qwen-code/sdk-typescript';
+import { query, isSDKAssistantMessage, type SDKMessage } from '@qwen-code/sdk';
 import {
   SDKTestHelper,
   extractText,

integration-tests/tsconfig.json

@@ -5,9 +5,7 @@
     "allowJs": true,
     "baseUrl": ".",
     "paths": {
-      "@qwen-code/sdk-typescript": [
-        "../packages/sdk-typescript/dist/index.d.ts"
-      ]
+      "@qwen-code/sdk": ["../packages/sdk-typescript/dist/index.d.ts"]
     }
   },
   "include": ["**/*.ts"],

integration-tests/vitest.config.ts

@@ -31,7 +31,7 @@ export default defineConfig({
   resolve: {
     alias: {
       // Use built SDK bundle for e2e tests
-      '@qwen-code/sdk-typescript': resolve(
+      '@qwen-code/sdk': resolve(
         __dirname,
         '../packages/sdk-typescript/dist/index.mjs',
       ),

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.4.0",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -13,7 +13,7 @@
     "url": "git+https://github.com/QwenLM/qwen-code.git"
   },
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.1-nightly.20251211.a02c4b27"
   },
   "scripts": {
     "start": "cross-env node scripts/start.js",
@@ -37,6 +37,10 @@
     "test:integration:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests",
     "test:integration:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests",
     "test:integration:sandbox:podman": "cross-env GEMINI_SANDBOX=podman vitest run --root ./integration-tests",
+    "test:integration:sdk:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests sdk-typescript",
+    "test:integration:sdk:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests sdk-typescript",
+    "test:integration:cli:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests --exclude '**/sdk-typescript/**'",
+    "test:integration:cli:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests --exclude '**/sdk-typescript/**'",
     "test:terminal-bench": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests",
     "test:terminal-bench:oracle": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests -t 'oracle'",
     "test:terminal-bench:qwen": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests -t 'qwen'",

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.4.0",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "description": "Qwen Code",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.1-nightly.20251211.a02c4b27"
   },
   "dependencies": {
     "@google/genai": "1.16.0",

packages/cli/src/gemini.tsx

@@ -276,8 +276,11 @@ export async function main() {
           process.exit(1);
         }
       }
+      // For stream-json mode, don't read stdin here - it should be forwarded to the sandbox
+      // and consumed by StreamJsonInputReader inside the container
+      const inputFormat = argv.inputFormat as string | undefined;
       let stdinData = '';
-      if (!process.stdin.isTTY) {
+      if (!process.stdin.isTTY && inputFormat !== 'stream-json') {
         stdinData = await readStdin();
       }
 

packages/cli/src/nonInteractive/control/ControlDispatcher.ts

@@ -16,9 +16,12 @@
  * Controllers:
  * - SystemController: initialize, interrupt, set_model, supported_commands
  * - PermissionController: can_use_tool, set_permission_mode
- * - MCPController: mcp_message, mcp_server_status
+ * - SdkMcpController: mcp_server_status (mcp_message handled via callback)
  * - HookController: hook_callback
  *
+ * Note: mcp_message requests are NOT routed through the dispatcher. CLI MCP
+ * clients send messages via SdkMcpController.createSendSdkMcpMessage() callback.
+ *
  * Note: Control request types are centrally defined in the ControlRequestType
  * enum in packages/sdk/typescript/src/types/controlRequests.ts
  */
@@ -27,7 +30,7 @@ import type { IControlContext } from './ControlContext.js';
 import type { IPendingRequestRegistry } from './controllers/baseController.js';
 import { SystemController } from './controllers/systemController.js';
 import { PermissionController } from './controllers/permissionController.js';
-// import { MCPController } from './controllers/mcpController.js';
+import { SdkMcpController } from './controllers/sdkMcpController.js';
 // import { HookController } from './controllers/hookController.js';
 import type {
   CLIControlRequest,
@@ -65,7 +68,7 @@ export class ControlDispatcher implements IPendingRequestRegistry {
   // Make controllers publicly accessible
   readonly systemController: SystemController;
   readonly permissionController: PermissionController;
-  // readonly mcpController: MCPController;
+  readonly sdkMcpController: SdkMcpController;
   // readonly hookController: HookController;
 
   // Central pending request registries
@@ -88,7 +91,11 @@ export class ControlDispatcher implements IPendingRequestRegistry {
       this,
       'PermissionController',
     );
-    // this.mcpController = new MCPController(context, this, 'MCPController');
+    this.sdkMcpController = new SdkMcpController(
+      context,
+      this,
+      'SdkMcpController',
+    );
     // this.hookController = new HookController(context, this, 'HookController');
 
     // Listen for main abort signal
@@ -228,10 +235,10 @@ export class ControlDispatcher implements IPendingRequestRegistry {
     }
     this.pendingOutgoingRequests.clear();
 
-    // Cleanup controllers (MCP controller will close all clients)
+    // Cleanup controllers
     this.systemController.cleanup();
     this.permissionController.cleanup();
-    // this.mcpController.cleanup();
+    this.sdkMcpController.cleanup();
     // this.hookController.cleanup();
   }
 
@@ -291,6 +298,47 @@ export class ControlDispatcher implements IPendingRequestRegistry {
     }
   }
 
+  /**
+   * Get count of pending incoming requests (for debugging)
+   */
+  getPendingIncomingRequestCount(): number {
+    return this.pendingIncomingRequests.size;
+  }
+
+  /**
+   * Wait for all incoming request handlers to complete.
+   *
+   * Uses polling since we don't have direct Promise references to handlers.
+   * The pendingIncomingRequests map is managed by BaseController:
+   * - Registered when handler starts (in handleRequest)
+   * - Deregistered when handler completes (success or error)
+   *
+   * @param pollIntervalMs - How often to check (default 50ms)
+   * @param timeoutMs - Maximum wait time (default 30s)
+   */
+  async waitForPendingIncomingRequests(
+    pollIntervalMs: number = 50,
+    timeoutMs: number = 30000,
+  ): Promise<void> {
+    const startTime = Date.now();
+
+    while (this.pendingIncomingRequests.size > 0) {
+      if (Date.now() - startTime > timeoutMs) {
+        if (this.context.debugMode) {
+          console.error(
+            `[ControlDispatcher] Timeout waiting for ${this.pendingIncomingRequests.size} pending incoming requests`,
+          );
+        }
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+
+    if (this.context.debugMode && this.pendingIncomingRequests.size === 0) {
+      console.error('[ControlDispatcher] All incoming requests completed');
+    }
+  }
+
   /**
    * Returns the controller that handles the given request subtype
    */
@@ -306,9 +354,8 @@ export class ControlDispatcher implements IPendingRequestRegistry {
       case 'set_permission_mode':
         return this.permissionController;
 
-      // case 'mcp_message':
-      // case 'mcp_server_status':
-      //   return this.mcpController;
+      case 'mcp_server_status':
+        return this.sdkMcpController;
 
       // case 'hook_callback':
       //   return this.hookController;

packages/cli/src/nonInteractive/control/controllers/baseController.ts

@@ -117,16 +117,41 @@ export abstract class BaseController {
    * Send an outgoing control request to SDK
    *
    * Manages lifecycle: register -> send -> wait for response -> deregister
+   * Respects the provided AbortSignal for cancellation.
    */
   async sendControlRequest(
     payload: ControlRequestPayload,
     timeoutMs: number = DEFAULT_REQUEST_TIMEOUT_MS,
+    signal?: AbortSignal,
   ): Promise<ControlResponse> {
+    // Check if already aborted
+    if (signal?.aborted) {
+      throw new Error('Request aborted');
+    }
+
     const requestId = randomUUID();
 
     return new Promise<ControlResponse>((resolve, reject) => {
+      // Setup abort handler
+      const abortHandler = () => {
+        this.registry.deregisterOutgoingRequest(requestId);
+        reject(new Error('Request aborted'));
+        if (this.context.debugMode) {
+          console.error(
+            `[${this.controllerName}] Outgoing request aborted: ${requestId}`,
+          );
+        }
+      };
+
+      if (signal) {
+        signal.addEventListener('abort', abortHandler, { once: true });
+      }
+
       // Setup timeout
       const timeoutId = setTimeout(() => {
+        if (signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
         this.registry.deregisterOutgoingRequest(requestId);
         reject(new Error('Control request timeout'));
         if (this.context.debugMode) {
@@ -136,12 +161,27 @@ export abstract class BaseController {
         }
       }, timeoutMs);
 
+      // Wrap resolve/reject to clean up abort listener
+      const wrappedResolve = (response: ControlResponse) => {
+        if (signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
+        resolve(response);
+      };
+
+      const wrappedReject = (error: Error) => {
+        if (signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
+        reject(error);
+      };
+
       // Register with central registry
       this.registry.registerOutgoingRequest(
         requestId,
         this.controllerName,
-        resolve,
-        reject,
+        wrappedResolve,
+        wrappedReject,
         timeoutId,
       );
 
@@ -155,6 +195,9 @@ export abstract class BaseController {
       try {
         this.context.streamJson.send(request);
       } catch (error) {
+        if (signal) {
+          signal.removeEventListener('abort', abortHandler);
+        }
         this.registry.deregisterOutgoingRequest(requestId);
         reject(error);
       }

packages/cli/src/nonInteractive/control/controllers/mcpController.ts

@@ -1,287 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * MCP Controller
- *
- * Handles MCP-related control requests:
- * - mcp_message: Route MCP messages
- * - mcp_server_status: Return MCP server status
- */
-
-import { BaseController } from './baseController.js';
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { ResultSchema } from '@modelcontextprotocol/sdk/types.js';
-import type {
-  ControlRequestPayload,
-  CLIControlMcpMessageRequest,
-} from '../../types.js';
-import type {
-  MCPServerConfig,
-  WorkspaceContext,
-} from '@qwen-code/qwen-code-core';
-import {
-  connectToMcpServer,
-  MCP_DEFAULT_TIMEOUT_MSEC,
-} from '@qwen-code/qwen-code-core';
-
-export class MCPController extends BaseController {
-  /**
-   * Handle MCP control requests
-   */
-  protected async handleRequestPayload(
-    payload: ControlRequestPayload,
-    _signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    switch (payload.subtype) {
-      case 'mcp_message':
-        return this.handleMcpMessage(payload as CLIControlMcpMessageRequest);
-
-      case 'mcp_server_status':
-        return this.handleMcpStatus();
-
-      default:
-        throw new Error(`Unsupported request subtype in MCPController`);
-    }
-  }
-
-  /**
-   * Handle mcp_message request
-   *
-   * Routes JSON-RPC messages to MCP servers
-   */
-  private async handleMcpMessage(
-    payload: CLIControlMcpMessageRequest,
-  ): Promise<Record<string, unknown>> {
-    const serverNameRaw = payload.server_name;
-    if (
-      typeof serverNameRaw !== 'string' ||
-      serverNameRaw.trim().length === 0
-    ) {
-      throw new Error('Missing server_name in mcp_message request');
-    }
-
-    const message = payload.message;
-    if (!message || typeof message !== 'object') {
-      throw new Error(
-        'Missing or invalid message payload for mcp_message request',
-      );
-    }
-
-    // Get or create MCP client
-    let clientEntry: { client: Client; config: MCPServerConfig };
-    try {
-      clientEntry = await this.getOrCreateMcpClient(serverNameRaw.trim());
-    } catch (error) {
-      throw new Error(
-        error instanceof Error
-          ? error.message
-          : 'Failed to connect to MCP server',
-      );
-    }
-
-    const method = message.method;
-    if (typeof method !== 'string' || method.trim().length === 0) {
-      throw new Error('Invalid MCP message: missing method');
-    }
-
-    const jsonrpcVersion =
-      typeof message.jsonrpc === 'string' ? message.jsonrpc : '2.0';
-    const messageId = message.id;
-    const params = message.params;
-    const timeout =
-      typeof clientEntry.config.timeout === 'number'
-        ? clientEntry.config.timeout
-        : MCP_DEFAULT_TIMEOUT_MSEC;
-
-    try {
-      // Handle notification (no id)
-      if (messageId === undefined) {
-        await clientEntry.client.notification({
-          method,
-          params,
-        });
-        return {
-          subtype: 'mcp_message',
-          mcp_response: {
-            jsonrpc: jsonrpcVersion,
-            id: null,
-            result: { success: true, acknowledged: true },
-          },
-        };
-      }
-
-      // Handle request (with id)
-      const result = await clientEntry.client.request(
-        {
-          method,
-          params,
-        },
-        ResultSchema,
-        { timeout },
-      );
-
-      return {
-        subtype: 'mcp_message',
-        mcp_response: {
-          jsonrpc: jsonrpcVersion,
-          id: messageId,
-          result,
-        },
-      };
-    } catch (error) {
-      // If connection closed, remove from cache
-      if (error instanceof Error && /closed/i.test(error.message)) {
-        this.context.mcpClients.delete(serverNameRaw.trim());
-      }
-
-      const errorCode =
-        typeof (error as { code?: unknown })?.code === 'number'
-          ? ((error as { code: number }).code as number)
-          : -32603;
-      const errorMessage =
-        error instanceof Error
-          ? error.message
-          : 'Failed to execute MCP request';
-      const errorData = (error as { data?: unknown })?.data;
-
-      const errorBody: Record<string, unknown> = {
-        code: errorCode,
-        message: errorMessage,
-      };
-      if (errorData !== undefined) {
-        errorBody['data'] = errorData;
-      }
-
-      return {
-        subtype: 'mcp_message',
-        mcp_response: {
-          jsonrpc: jsonrpcVersion,
-          id: messageId ?? null,
-          error: errorBody,
-        },
-      };
-    }
-  }
-
-  /**
-   * Handle mcp_server_status request
-   *
-   * Returns status of registered MCP servers
-   */
-  private async handleMcpStatus(): Promise<Record<string, unknown>> {
-    const status: Record<string, string> = {};
-
-    // Include SDK MCP servers
-    for (const serverName of this.context.sdkMcpServers) {
-      status[serverName] = 'connected';
-    }
-
-    // Include CLI-managed MCP clients
-    for (const serverName of this.context.mcpClients.keys()) {
-      status[serverName] = 'connected';
-    }
-
-    if (this.context.debugMode) {
-      console.error(
-        `[MCPController] MCP status: ${Object.keys(status).length} servers`,
-      );
-    }
-
-    return status;
-  }
-
-  /**
-   * Get or create MCP client for a server
-   *
-   * Implements lazy connection and caching
-   */
-  private async getOrCreateMcpClient(
-    serverName: string,
-  ): Promise<{ client: Client; config: MCPServerConfig }> {
-    // Check cache first
-    const cached = this.context.mcpClients.get(serverName);
-    if (cached) {
-      return cached;
-    }
-
-    // Get server configuration
-    const provider = this.context.config as unknown as {
-      getMcpServers?: () => Record<string, MCPServerConfig> | undefined;
-      getDebugMode?: () => boolean;
-      getWorkspaceContext?: () => unknown;
-    };
-
-    if (typeof provider.getMcpServers !== 'function') {
-      throw new Error(`MCP server "${serverName}" is not configured`);
-    }
-
-    const servers = provider.getMcpServers() ?? {};
-    const serverConfig = servers[serverName];
-    if (!serverConfig) {
-      throw new Error(`MCP server "${serverName}" is not configured`);
-    }
-
-    const debugMode =
-      typeof provider.getDebugMode === 'function'
-        ? provider.getDebugMode()
-        : false;
-
-    const workspaceContext =
-      typeof provider.getWorkspaceContext === 'function'
-        ? provider.getWorkspaceContext()
-        : undefined;
-
-    if (!workspaceContext) {
-      throw new Error('Workspace context is not available for MCP connection');
-    }
-
-    // Connect to MCP server
-    const client = await connectToMcpServer(
-      serverName,
-      serverConfig,
-      debugMode,
-      workspaceContext as WorkspaceContext,
-    );
-
-    // Cache the client
-    const entry = { client, config: serverConfig };
-    this.context.mcpClients.set(serverName, entry);
-
-    if (this.context.debugMode) {
-      console.error(`[MCPController] Connected to MCP server: ${serverName}`);
-    }
-
-    return entry;
-  }
-
-  /**
-   * Cleanup MCP clients
-   */
-  override cleanup(): void {
-    if (this.context.debugMode) {
-      console.error(
-        `[MCPController] Cleaning up ${this.context.mcpClients.size} MCP clients`,
-      );
-    }
-
-    // Close all MCP clients
-    for (const [serverName, { client }] of this.context.mcpClients.entries()) {
-      try {
-        client.close();
-      } catch (error) {
-        if (this.context.debugMode) {
-          console.error(
-            `[MCPController] Failed to close MCP client ${serverName}:`,
-            error,
-          );
-        }
-      }
-    }
-
-    this.context.mcpClients.clear();
-  }
-}

packages/cli/src/nonInteractive/control/controllers/permissionController.ts

@@ -44,15 +44,23 @@ export class PermissionController extends BaseController {
    */
   protected async handleRequestPayload(
     payload: ControlRequestPayload,
-    _signal: AbortSignal,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     switch (payload.subtype) {
       case 'can_use_tool':
-        return this.handleCanUseTool(payload as CLIControlPermissionRequest);
+        return this.handleCanUseTool(
+          payload as CLIControlPermissionRequest,
+          signal,
+        );
 
       case 'set_permission_mode':
         return this.handleSetPermissionMode(
           payload as CLIControlSetPermissionModeRequest,
+          signal,
         );
 
       default:
@@ -70,7 +78,12 @@ export class PermissionController extends BaseController {
    */
   private async handleCanUseTool(
     payload: CLIControlPermissionRequest,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     const toolName = payload.tool_name;
     if (
       !toolName ||
@@ -192,7 +205,12 @@ export class PermissionController extends BaseController {
    */
   private async handleSetPermissionMode(
     payload: CLIControlSetPermissionModeRequest,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     const mode = payload.mode;
     const validModes: PermissionMode[] = [
       'default',
@@ -373,6 +391,14 @@ export class PermissionController extends BaseController {
     toolCall: WaitingToolCall,
   ): Promise<void> {
     try {
+      // Check if already aborted
+      if (this.context.abortSignal?.aborted) {
+        await toolCall.confirmationDetails.onConfirm(
+          ToolConfirmationOutcome.Cancel,
+        );
+        return;
+      }
+
       const inputFormat = this.context.config.getInputFormat?.();
       const isStreamJsonMode = inputFormat === InputFormat.STREAM_JSON;
 
@@ -392,14 +418,18 @@ export class PermissionController extends BaseController {
         toolCall.confirmationDetails,
       );
 
-      const response = await this.sendControlRequest({
-        subtype: 'can_use_tool',
-        tool_name: toolCall.request.name,
-        tool_use_id: toolCall.request.callId,
-        input: toolCall.request.args,
-        permission_suggestions: permissionSuggestions,
-        blocked_path: null,
-      } as CLIControlPermissionRequest);
+      const response = await this.sendControlRequest(
+        {
+          subtype: 'can_use_tool',
+          tool_name: toolCall.request.name,
+          tool_use_id: toolCall.request.callId,
+          input: toolCall.request.args,
+          permission_suggestions: permissionSuggestions,
+          blocked_path: null,
+        } as CLIControlPermissionRequest,
+        undefined, // use default timeout
+        this.context.abortSignal,
+      );
 
       if (response.subtype !== 'success') {
         await toolCall.confirmationDetails.onConfirm(

packages/cli/src/nonInteractive/control/controllers/sdkMcpController.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * SDK MCP Controller
+ *
+ * Handles MCP communication between CLI MCP clients and SDK MCP servers:
+ * - Provides sendSdkMcpMessage callback for CLI → SDK MCP message routing
+ * - mcp_server_status: Returns status of SDK MCP servers
+ *
+ * Message Flow (CLI MCP Client → SDK MCP Server):
+ * CLI MCP Client → SdkControlClientTransport.send() →
+ * sendSdkMcpMessage callback → control_request (mcp_message) → SDK →
+ * SDK MCP Server processes → control_response → CLI MCP Client
+ */
+
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { BaseController } from './baseController.js';
+import type {
+  ControlRequestPayload,
+  CLIControlMcpMessageRequest,
+} from '../../types.js';
+
+const MCP_REQUEST_TIMEOUT = 30_000; // 30 seconds
+
+export class SdkMcpController extends BaseController {
+  /**
+   * Handle SDK MCP control requests from ControlDispatcher
+   *
+   * Note: mcp_message requests are NOT handled here. CLI MCP clients
+   * send messages via the sendSdkMcpMessage callback directly, not
+   * through the control dispatcher.
+   */
+  protected async handleRequestPayload(
+    payload: ControlRequestPayload,
+    signal: AbortSignal,
+  ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
+    switch (payload.subtype) {
+      case 'mcp_server_status':
+        return this.handleMcpStatus();
+
+      default:
+        throw new Error(`Unsupported request subtype in SdkMcpController`);
+    }
+  }
+
+  /**
+   * Handle mcp_server_status request
+   *
+   * Returns status of all registered SDK MCP servers.
+   * SDK servers are considered "connected" if they are registered.
+   */
+  private async handleMcpStatus(): Promise<Record<string, unknown>> {
+    const status: Record<string, string> = {};
+
+    for (const serverName of this.context.sdkMcpServers) {
+      // SDK MCP servers are "connected" once registered since they run in SDK process
+      status[serverName] = 'connected';
+    }
+
+    return {
+      subtype: 'mcp_server_status',
+      status,
+    };
+  }
+
+  /**
+   * Send MCP message to SDK server via control plane
+   *
+   * @param serverName - Name of the SDK MCP server
+   * @param message - MCP JSON-RPC message to send
+   * @returns MCP JSON-RPC response from SDK server
+   */
+  private async sendMcpMessageToSdk(
+    serverName: string,
+    message: JSONRPCMessage,
+  ): Promise<JSONRPCMessage> {
+    if (this.context.debugMode) {
+      console.error(
+        `[SdkMcpController] Sending MCP message to SDK server '${serverName}':`,
+        JSON.stringify(message),
+      );
+    }
+
+    // Send control request to SDK with the MCP message
+    const response = await this.sendControlRequest(
+      {
+        subtype: 'mcp_message',
+        server_name: serverName,
+        message: message as CLIControlMcpMessageRequest['message'],
+      },
+      MCP_REQUEST_TIMEOUT,
+      this.context.abortSignal,
+    );
+
+    // Extract MCP response from control response
+    const responsePayload = response.response as Record<string, unknown>;
+    const mcpResponse = responsePayload?.['mcp_response'] as JSONRPCMessage;
+
+    if (!mcpResponse) {
+      throw new Error(
+        `Invalid MCP response from SDK for server '${serverName}'`,
+      );
+    }
+
+    if (this.context.debugMode) {
+      console.error(
+        `[SdkMcpController] Received MCP response from SDK server '${serverName}':`,
+        JSON.stringify(mcpResponse),
+      );
+    }
+
+    return mcpResponse;
+  }
+
+  /**
+   * Create a callback function for sending MCP messages to SDK servers.
+   *
+   * This callback is used by McpClientManager/SdkControlClientTransport to send
+   * MCP messages from CLI MCP clients to SDK MCP servers via the control plane.
+   *
+   * @returns A function that sends MCP messages to SDK and returns the response
+   */
+  createSendSdkMcpMessage(): (
+    serverName: string,
+    message: JSONRPCMessage,
+  ) => Promise<JSONRPCMessage> {
+    return (serverName: string, message: JSONRPCMessage) =>
+      this.sendMcpMessageToSdk(serverName, message);
+  }
+}

packages/cli/src/nonInteractive/control/controllers/systemController.ts

@@ -18,9 +18,15 @@ import type {
   ControlRequestPayload,
   CLIControlInitializeRequest,
   CLIControlSetModelRequest,
+  CLIMcpServerConfig,
 } from '../../types.js';
 import { CommandService } from '../../../services/CommandService.js';
 import { BuiltinCommandLoader } from '../../../services/BuiltinCommandLoader.js';
+import {
+  MCPServerConfig,
+  AuthProviderType,
+  type MCPOAuthConfig,
+} from '@qwen-code/qwen-code-core';
 
 export class SystemController extends BaseController {
   /**
@@ -28,20 +34,30 @@ export class SystemController extends BaseController {
    */
   protected async handleRequestPayload(
     payload: ControlRequestPayload,
-    _signal: AbortSignal,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     switch (payload.subtype) {
       case 'initialize':
-        return this.handleInitialize(payload as CLIControlInitializeRequest);
+        return this.handleInitialize(
+          payload as CLIControlInitializeRequest,
+          signal,
+        );
 
       case 'interrupt':
         return this.handleInterrupt();
 
       case 'set_model':
-        return this.handleSetModel(payload as CLIControlSetModelRequest);
+        return this.handleSetModel(
+          payload as CLIControlSetModelRequest,
+          signal,
+        );
 
       case 'supported_commands':
-        return this.handleSupportedCommands();
+        return this.handleSupportedCommands(signal);
 
       default:
         throw new Error(`Unsupported request subtype in SystemController`);
@@ -51,46 +67,110 @@ export class SystemController extends BaseController {
   /**
    * Handle initialize request
    *
-   * Registers SDK MCP servers and returns capabilities
+   * Processes SDK MCP servers config.
+   * SDK servers are registered in context.sdkMcpServers
+   * and added to config.mcpServers with the sdk type flag.
+   * External MCP servers are configured separately in settings.
    */
   private async handleInitialize(
     payload: CLIControlInitializeRequest,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     this.context.config.setSdkMode(true);
 
-    if (payload.sdkMcpServers && typeof payload.sdkMcpServers === 'object') {
-      for (const serverName of Object.keys(payload.sdkMcpServers)) {
-        this.context.sdkMcpServers.add(serverName);
+    // Process SDK MCP servers
+    if (
+      payload.sdkMcpServers &&
+      typeof payload.sdkMcpServers === 'object' &&
+      payload.sdkMcpServers !== null
+    ) {
+      const sdkServers: Record<string, MCPServerConfig> = {};
+      for (const [key, wireConfig] of Object.entries(payload.sdkMcpServers)) {
+        const name =
+          typeof wireConfig?.name === 'string' && wireConfig.name.trim().length
+            ? wireConfig.name
+            : key;
+
+        this.context.sdkMcpServers.add(name);
+        sdkServers[name] = new MCPServerConfig(
+          undefined, // command
+          undefined, // args
+          undefined, // env
+          undefined, // cwd
+          undefined, // url
+          undefined, // httpUrl
+          undefined, // headers
+          undefined, // tcp
+          undefined, // timeout
+          true, // trust - SDK servers are trusted
+          undefined, // description
+          undefined, // includeTools
+          undefined, // excludeTools
+          undefined, // extensionName
+          undefined, // oauth
+          undefined, // authProviderType
+          undefined, // targetAudience
+          undefined, // targetServiceAccount
+          'sdk', // type
+        );
       }
 
-      try {
-        this.context.config.addMcpServers(payload.sdkMcpServers);
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Added ${Object.keys(payload.sdkMcpServers).length} SDK MCP servers to config`,
-          );
-        }
-      } catch (error) {
-        if (this.context.debugMode) {
-          console.error(
-            '[SystemController] Failed to add SDK MCP servers:',
-            error,
-          );
+      const sdkServerCount = Object.keys(sdkServers).length;
+      if (sdkServerCount > 0) {
+        try {
+          this.context.config.addMcpServers(sdkServers);
+          if (this.context.debugMode) {
+            console.error(
+              `[SystemController] Added ${sdkServerCount} SDK MCP servers to config`,
+            );
+          }
+        } catch (error) {
+          if (this.context.debugMode) {
+            console.error(
+              '[SystemController] Failed to add SDK MCP servers:',
+              error,
+            );
+          }
         }
       }
     }
 
-    if (payload.mcpServers && typeof payload.mcpServers === 'object') {
-      try {
-        this.context.config.addMcpServers(payload.mcpServers);
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Added ${Object.keys(payload.mcpServers).length} MCP servers to config`,
-          );
+    if (
+      payload.mcpServers &&
+      typeof payload.mcpServers === 'object' &&
+      payload.mcpServers !== null
+    ) {
+      const externalServers: Record<string, MCPServerConfig> = {};
+      for (const [name, serverConfig] of Object.entries(payload.mcpServers)) {
+        const normalized = this.normalizeMcpServerConfig(
+          name,
+          serverConfig as CLIMcpServerConfig | undefined,
+        );
+        if (normalized) {
+          externalServers[name] = normalized;
         }
-      } catch (error) {
-        if (this.context.debugMode) {
-          console.error('[SystemController] Failed to add MCP servers:', error);
+      }
+
+      const externalCount = Object.keys(externalServers).length;
+      if (externalCount > 0) {
+        try {
+          this.context.config.addMcpServers(externalServers);
+          if (this.context.debugMode) {
+            console.error(
+              `[SystemController] Added ${externalCount} external MCP servers to config`,
+            );
+          }
+        } catch (error) {
+          if (this.context.debugMode) {
+            console.error(
+              '[SystemController] Failed to add external MCP servers:',
+              error,
+            );
+          }
         }
       }
     }
@@ -143,13 +223,96 @@ export class SystemController extends BaseController {
       can_set_permission_mode:
         typeof this.context.config.setApprovalMode === 'function',
       can_set_model: typeof this.context.config.setModel === 'function',
-      /* TODO: sdkMcpServers support */
-      can_handle_mcp_message: false,
+      // SDK MCP servers are supported - messages routed through control plane
+      can_handle_mcp_message: true,
     };
 
     return capabilities;
   }
 
+  private normalizeMcpServerConfig(
+    serverName: string,
+    config?: CLIMcpServerConfig,
+  ): MCPServerConfig | null {
+    if (!config || typeof config !== 'object') {
+      if (this.context.debugMode) {
+        console.error(
+          `[SystemController] Ignoring invalid MCP server config for '${serverName}'`,
+        );
+      }
+      return null;
+    }
+
+    const authProvider = this.normalizeAuthProviderType(
+      config.authProviderType,
+    );
+    const oauthConfig = this.normalizeOAuthConfig(config.oauth);
+
+    return new MCPServerConfig(
+      config.command,
+      config.args,
+      config.env,
+      config.cwd,
+      config.url,
+      config.httpUrl,
+      config.headers,
+      config.tcp,
+      config.timeout,
+      config.trust,
+      config.description,
+      config.includeTools,
+      config.excludeTools,
+      config.extensionName,
+      oauthConfig,
+      authProvider,
+      config.targetAudience,
+      config.targetServiceAccount,
+    );
+  }
+
+  private normalizeAuthProviderType(
+    value?: string,
+  ): AuthProviderType | undefined {
+    if (!value) {
+      return undefined;
+    }
+
+    switch (value) {
+      case AuthProviderType.DYNAMIC_DISCOVERY:
+      case AuthProviderType.GOOGLE_CREDENTIALS:
+      case AuthProviderType.SERVICE_ACCOUNT_IMPERSONATION:
+        return value;
+      default:
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Unsupported authProviderType '${value}', skipping`,
+          );
+        }
+        return undefined;
+    }
+  }
+
+  private normalizeOAuthConfig(
+    oauth?: CLIMcpServerConfig['oauth'],
+  ): MCPOAuthConfig | undefined {
+    if (!oauth) {
+      return undefined;
+    }
+
+    return {
+      enabled: oauth.enabled,
+      clientId: oauth.clientId,
+      clientSecret: oauth.clientSecret,
+      authorizationUrl: oauth.authorizationUrl,
+      tokenUrl: oauth.tokenUrl,
+      scopes: oauth.scopes,
+      audiences: oauth.audiences,
+      redirectUri: oauth.redirectUri,
+      tokenParamName: oauth.tokenParamName,
+      registrationUrl: oauth.registrationUrl,
+    };
+  }
+
   /**
    * Handle interrupt request
    *
@@ -183,7 +346,12 @@ export class SystemController extends BaseController {
    */
   private async handleSetModel(
     payload: CLIControlSetModelRequest,
+    signal: AbortSignal,
   ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
     const model = payload.model;
 
     // Validate model parameter
@@ -223,8 +391,14 @@ export class SystemController extends BaseController {
    *
    * Returns list of supported slash commands loaded dynamically
    */
-  private async handleSupportedCommands(): Promise<Record<string, unknown>> {
-    const slashCommands = await this.loadSlashCommandNames();
+  private async handleSupportedCommands(
+    signal: AbortSignal,
+  ): Promise<Record<string, unknown>> {
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
+    const slashCommands = await this.loadSlashCommandNames(signal);
 
     return {
       subtype: 'supported_commands',
@@ -235,15 +409,24 @@ export class SystemController extends BaseController {
   /**
    * Load slash command names using CommandService
    *
+   * @param signal - AbortSignal to respect for cancellation
    * @returns Promise resolving to array of slash command names
    */
-  private async loadSlashCommandNames(): Promise<string[]> {
-    const controller = new AbortController();
+  private async loadSlashCommandNames(signal: AbortSignal): Promise<string[]> {
+    if (signal.aborted) {
+      return [];
+    }
+
     try {
       const service = await CommandService.create(
         [new BuiltinCommandLoader(this.context.config)],
-        controller.signal,
+        signal,
       );
+
+      if (signal.aborted) {
+        return [];
+      }
+
       const names = new Set<string>();
       const commands = service.getCommands();
       for (const command of commands) {
@@ -251,6 +434,11 @@ export class SystemController extends BaseController {
       }
       return Array.from(names).sort();
     } catch (error) {
+      // Check if the error is due to abort
+      if (signal.aborted) {
+        return [];
+      }
+
       if (this.context.debugMode) {
         console.error(
           '[SystemController] Failed to load slash commands:',
@@ -258,8 +446,6 @@ export class SystemController extends BaseController {
         );
       }
       return [];
-    } finally {
-      controller.abort();
     }
   }
 }

packages/cli/src/nonInteractive/session.test.ts

@@ -153,6 +153,11 @@ describe('runNonInteractiveStreamJson', () => {
     handleControlResponse: ReturnType<typeof vi.fn>;
     handleCancel: ReturnType<typeof vi.fn>;
     shutdown: ReturnType<typeof vi.fn>;
+    getPendingIncomingRequestCount: ReturnType<typeof vi.fn>;
+    waitForPendingIncomingRequests: ReturnType<typeof vi.fn>;
+    sdkMcpController: {
+      createSendSdkMcpMessage: ReturnType<typeof vi.fn>;
+    };
   };
   let mockConsolePatcher: {
     patch: ReturnType<typeof vi.fn>;
@@ -187,6 +192,11 @@ describe('runNonInteractiveStreamJson', () => {
       handleControlResponse: vi.fn(),
       handleCancel: vi.fn(),
       shutdown: vi.fn(),
+      getPendingIncomingRequestCount: vi.fn().mockReturnValue(0),
+      waitForPendingIncomingRequests: vi.fn().mockResolvedValue(undefined),
+      sdkMcpController: {
+        createSendSdkMcpMessage: vi.fn().mockReturnValue(vi.fn()),
+      },
     };
     (
       ControlDispatcher as unknown as ReturnType<typeof vi.fn>

packages/cli/src/nonInteractive/session.ts

@@ -4,7 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Config } from '@qwen-code/qwen-code-core';
+import type {
+  Config,
+  ConfigInitializeOptions,
+} from '@qwen-code/qwen-code-core';
 import { StreamJsonInputReader } from './io/StreamJsonInputReader.js';
 import { StreamJsonOutputAdapter } from './io/StreamJsonOutputAdapter.js';
 import { ControlContext } from './control/ControlContext.js';
@@ -50,6 +53,12 @@ class Session {
   private isShuttingDown: boolean = false;
   private configInitialized: boolean = false;
 
+  // Single initialization promise that resolves when session is ready for user messages.
+  // Created lazily once initialization actually starts.
+  private initializationPromise: Promise<void> | null = null;
+  private initializationResolve: (() => void) | null = null;
+  private initializationReject: ((error: Error) => void) | null = null;
+
   constructor(config: Config, initialPrompt?: CLIUserMessage) {
     this.config = config;
     this.sessionId = config.getSessionId();
@@ -66,12 +75,32 @@ class Session {
     this.setupSignalHandlers();
   }
 
+  private ensureInitializationPromise(): void {
+    if (this.initializationPromise) {
+      return;
+    }
+    this.initializationPromise = new Promise<void>((resolve, reject) => {
+      this.initializationResolve = () => {
+        resolve();
+        this.initializationResolve = null;
+        this.initializationReject = null;
+      };
+      this.initializationReject = (error: Error) => {
+        reject(error);
+        this.initializationResolve = null;
+        this.initializationReject = null;
+      };
+    });
+  }
+
   private getNextPromptId(): string {
     this.promptIdCounter++;
     return `${this.sessionId}########${this.promptIdCounter}`;
   }
 
-  private async ensureConfigInitialized(): Promise<void> {
+  private async ensureConfigInitialized(
+    options?: ConfigInitializeOptions,
+  ): Promise<void> {
     if (this.configInitialized) {
       return;
     }
@@ -81,7 +110,7 @@ class Session {
     }
 
     try {
-      await this.config.initialize();
+      await this.config.initialize(options);
       this.configInitialized = true;
     } catch (error) {
       if (this.debugMode) {
@@ -91,6 +120,44 @@ class Session {
     }
   }
 
+  /**
+   * Mark initialization as complete
+   */
+  private completeInitialization(): void {
+    if (this.initializationResolve) {
+      if (this.debugMode) {
+        console.error('[Session] Initialization complete');
+      }
+      this.initializationResolve();
+      this.initializationResolve = null;
+      this.initializationReject = null;
+    }
+  }
+
+  /**
+   * Mark initialization as failed
+   */
+  private failInitialization(error: Error): void {
+    if (this.initializationReject) {
+      if (this.debugMode) {
+        console.error('[Session] Initialization failed:', error);
+      }
+      this.initializationReject(error);
+      this.initializationResolve = null;
+      this.initializationReject = null;
+    }
+  }
+
+  /**
+   * Wait for session to be ready for user messages
+   */
+  private async waitForInitialization(): Promise<void> {
+    if (!this.initializationPromise) {
+      return;
+    }
+    await this.initializationPromise;
+  }
+
   private ensureControlSystem(): void {
     if (this.controlContext && this.dispatcher && this.controlService) {
       return;
@@ -120,49 +187,114 @@ class Session {
     return this.dispatcher;
   }
 
-  private async handleFirstMessage(
+  /**
+   * Handle the first message to determine session mode (SDK vs direct).
+   * This is synchronous from the message loop's perspective - it starts
+   * async work but does not return a promise that the loop awaits.
+   *
+   * The initialization completes asynchronously and resolves initializationPromise
+   * when ready for user messages.
+   */
+  private handleFirstMessage(
     message:
       | CLIMessage
       | CLIControlRequest
       | CLIControlResponse
       | ControlCancelRequest,
-  ): Promise<boolean> {
+  ): void {
     if (isControlRequest(message)) {
       const request = message as CLIControlRequest;
       this.controlSystemEnabled = true;
       this.ensureControlSystem();
-      if (request.request.subtype === 'initialize') {
-        // Dispatch the initialize request first
-        await this.dispatcher?.dispatch(request);
 
-        // After handling initialize control request, initialize the config
-        // This is the SDK mode where config initialization is deferred
-        await this.ensureConfigInitialized();
-        return true;
+      if (request.request.subtype === 'initialize') {
+        // Start SDK mode initialization (fire-and-forget from loop perspective)
+        void this.initializeSdkMode(request);
+        return;
       }
+
       if (this.debugMode) {
         console.error(
           '[Session] Ignoring non-initialize control request during initialization',
         );
       }
-      return true;
+      return;
     }
 
     if (isCLIUserMessage(message)) {
       this.controlSystemEnabled = false;
-      // For non-SDK mode (direct user message), initialize config if not already done
-      await this.ensureConfigInitialized();
-      this.enqueueUserMessage(message as CLIUserMessage);
-      return true;
+      // Start direct mode initialization (fire-and-forget from loop perspective)
+      void this.initializeDirectMode(message as CLIUserMessage);
+      return;
     }
 
     this.controlSystemEnabled = false;
-    return false;
   }
 
-  private async handleControlRequest(
-    request: CLIControlRequest,
+  /**
+   * SDK mode initialization flow
+   * Dispatches initialize request and initializes config with MCP support
+   */
+  private async initializeSdkMode(request: CLIControlRequest): Promise<void> {
+    this.ensureInitializationPromise();
+    try {
+      // Dispatch the initialize request first
+      // This registers SDK MCP servers in the control context
+      await this.dispatcher?.dispatch(request);
+
+      // Get sendSdkMcpMessage callback from SdkMcpController
+      // This callback is used by McpClientManager to send MCP messages
+      // from CLI MCP clients to SDK MCP servers via the control plane
+      const sendSdkMcpMessage =
+        this.dispatcher?.sdkMcpController.createSendSdkMcpMessage();
+
+      // Initialize config with SDK MCP message support
+      await this.ensureConfigInitialized({ sendSdkMcpMessage });
+
+      // Initialization complete!
+      this.completeInitialization();
+    } catch (error) {
+      if (this.debugMode) {
+        console.error('[Session] SDK mode initialization failed:', error);
+      }
+      this.failInitialization(
+        error instanceof Error ? error : new Error(String(error)),
+      );
+    }
+  }
+
+  /**
+   * Direct mode initialization flow
+   * Initializes config and enqueues the first user message
+   */
+  private async initializeDirectMode(
+    userMessage: CLIUserMessage,
   ): Promise<void> {
+    this.ensureInitializationPromise();
+    try {
+      // Initialize config
+      await this.ensureConfigInitialized();
+
+      // Initialization complete!
+      this.completeInitialization();
+
+      // Enqueue the first user message for processing
+      this.enqueueUserMessage(userMessage);
+    } catch (error) {
+      if (this.debugMode) {
+        console.error('[Session] Direct mode initialization failed:', error);
+      }
+      this.failInitialization(
+        error instanceof Error ? error : new Error(String(error)),
+      );
+    }
+  }
+
+  /**
+   * Handle control request asynchronously (fire-and-forget from main loop).
+   * Errors are handled internally and responses sent by dispatcher.
+   */
+  private handleControlRequestAsync(request: CLIControlRequest): void {
     const dispatcher = this.getDispatcher();
     if (!dispatcher) {
       if (this.debugMode) {
@@ -171,9 +303,20 @@ class Session {
       return;
     }
 
-    await dispatcher.dispatch(request);
+    // Fire-and-forget: dispatch runs concurrently
+    // The dispatcher's pendingIncomingRequests tracks completion
+    void dispatcher.dispatch(request).catch((error) => {
+      if (this.debugMode) {
+        console.error('[Session] Control request dispatch error:', error);
+      }
+      // Error response is already sent by dispatcher.dispatch()
+    });
   }
 
+  /**
+   * Handle control response - MUST be synchronous
+   * This resolves pending outgoing requests, breaking the deadlock cycle.
+   */
   private handleControlResponse(response: CLIControlResponse): void {
     const dispatcher = this.getDispatcher();
     if (!dispatcher) {
@@ -201,8 +344,8 @@ class Session {
       return;
     }
 
-    // Ensure config is initialized before processing user messages
-    await this.ensureConfigInitialized();
+    // Wait for initialization to complete before processing user messages
+    await this.waitForInitialization();
 
     const promptId = this.getNextPromptId();
 
@@ -307,6 +450,45 @@ class Session {
     process.on('SIGTERM', this.shutdownHandler);
   }
 
+  /**
+   * Wait for all pending work to complete before shutdown
+   */
+  private async waitForAllPendingWork(): Promise<void> {
+    // 1. Wait for initialization to complete (or fail)
+    try {
+      await this.waitForInitialization();
+    } catch (error) {
+      if (this.debugMode) {
+        console.error('[Session] Initialization error during shutdown:', error);
+      }
+    }
+
+    // 2. Wait for all control request handlers using dispatcher's tracking
+    if (this.dispatcher) {
+      const pendingCount = this.dispatcher.getPendingIncomingRequestCount();
+      if (pendingCount > 0 && this.debugMode) {
+        console.error(
+          `[Session] Waiting for ${pendingCount} pending control request handlers`,
+        );
+      }
+      await this.dispatcher.waitForPendingIncomingRequests();
+    }
+
+    // 3. Wait for user message processing queue
+    while (this.processingPromise) {
+      if (this.debugMode) {
+        console.error('[Session] Waiting for user message processing');
+      }
+      try {
+        await this.processingPromise;
+      } catch (error) {
+        if (this.debugMode) {
+          console.error('[Session] Error in user message processing:', error);
+        }
+      }
+    }
+  }
+
   private async shutdown(): Promise<void> {
     if (this.debugMode) {
       console.error('[Session] Shutting down');
@@ -314,18 +496,8 @@ class Session {
 
     this.isShuttingDown = true;
 
-    if (this.processingPromise) {
-      try {
-        await this.processingPromise;
-      } catch (error) {
-        if (this.debugMode) {
-          console.error(
-            '[Session] Error waiting for processing to complete:',
-            error,
-          );
-        }
-      }
-    }
+    // Wait for all pending work
+    await this.waitForAllPendingWork();
 
     this.dispatcher?.shutdown();
     this.cleanupSignalHandlers();
@@ -339,18 +511,30 @@ class Session {
     }
   }
 
+  /**
+   * Main message processing loop
+   *
+   * CRITICAL: This loop must NEVER await handlers that might need to
+   * send control requests and wait for responses. Such handlers must
+   * be started in fire-and-forget mode, allowing the loop to continue
+   * reading responses that resolve pending requests.
+   *
+   * Message handling order:
+   * 1. control_response - FIRST, synchronously resolves pending requests
+   * 2. First message - determines mode, starts async initialization
+   * 3. control_request - fire-and-forget, tracked by dispatcher
+   * 4. control_cancel - synchronous
+   * 5. user_message - enqueued for processing
+   */
   async run(): Promise<void> {
     try {
       if (this.debugMode) {
         console.error('[Session] Starting session', this.sessionId);
       }
 
+      // Handle initial prompt if provided (fire-and-forget)
       if (this.initialPrompt !== null) {
-        const handled = await this.handleFirstMessage(this.initialPrompt);
-        if (handled && this.isShuttingDown) {
-          await this.shutdown();
-          return;
-        }
+        this.handleFirstMessage(this.initialPrompt);
       }
 
       try {
@@ -359,23 +543,33 @@ class Session {
             break;
           }
 
-          if (this.controlSystemEnabled === null) {
-            const handled = await this.handleFirstMessage(message);
-            if (handled) {
-              if (this.isShuttingDown) {
-                break;
-              }
-              continue;
-            }
+          // ============================================================
+          // CRITICAL: Handle control_response FIRST and SYNCHRONOUSLY
+          // This resolves pending outgoing requests, breaking deadlock.
+          // ============================================================
+          if (isControlResponse(message)) {
+            this.handleControlResponse(message as CLIControlResponse);
+            continue;
           }
 
+          // Handle first message to determine session mode
+          if (this.controlSystemEnabled === null) {
+            this.handleFirstMessage(message);
+            continue;
+          }
+
+          // ============================================================
+          // CRITICAL: Handle control_request in FIRE-AND-FORGET mode
+          // DON'T await - let handler run concurrently while loop continues
+          // Dispatcher's pendingIncomingRequests tracks completion
+          // ============================================================
           if (isControlRequest(message)) {
-            await this.handleControlRequest(message as CLIControlRequest);
-          } else if (isControlResponse(message)) {
-            this.handleControlResponse(message as CLIControlResponse);
+            this.handleControlRequestAsync(message as CLIControlRequest);
           } else if (isControlCancel(message)) {
+            // Cancel is synchronous - OK to handle inline
             this.handleControlCancel(message as ControlCancelRequest);
           } else if (isCLIUserMessage(message)) {
+            // User messages are enqueued, processing runs separately
             this.enqueueUserMessage(message as CLIUserMessage);
           } else if (this.debugMode) {
             if (
@@ -402,19 +596,8 @@ class Session {
         throw streamError;
       }
 
-      while (this.processingPromise) {
-        if (this.debugMode) {
-          console.error('[Session] Waiting for final processing to complete');
-        }
-        try {
-          await this.processingPromise;
-        } catch (error) {
-          if (this.debugMode) {
-            console.error('[Session] Error in final processing:', error);
-          }
-        }
-      }
-
+      // Stream ended - wait for all pending work before shutdown
+      await this.waitForAllPendingWork();
       await this.shutdown();
     } catch (error) {
       if (this.debugMode) {

packages/cli/src/nonInteractive/types.ts

@@ -1,8 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type {
-  MCPServerConfig,
-  SubagentConfig,
-} from '@qwen-code/qwen-code-core';
+import type { SubagentConfig } from '@qwen-code/qwen-code-core';
 
 /**
  * Annotation for attaching metadata to content blocks
@@ -298,11 +295,68 @@ export interface CLIControlPermissionRequest {
   blocked_path: string | null;
 }
 
+/**
+ * Wire format for SDK MCP server config in initialization request.
+ * The actual Server instance stays in the SDK process.
+ */
+export interface SDKMcpServerConfig {
+  type: 'sdk';
+  name: string;
+}
+
+/**
+ * Wire format for external MCP server config in initialization request.
+ * Represents stdio/SSE/HTTP/TCP transports that must run in the CLI process.
+ */
+export interface CLIMcpServerConfig {
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  url?: string;
+  httpUrl?: string;
+  headers?: Record<string, string>;
+  tcp?: string;
+  timeout?: number;
+  trust?: boolean;
+  description?: string;
+  includeTools?: string[];
+  excludeTools?: string[];
+  extensionName?: string;
+  oauth?: {
+    enabled?: boolean;
+    clientId?: string;
+    clientSecret?: string;
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    scopes?: string[];
+    audiences?: string[];
+    redirectUri?: string;
+    tokenParamName?: string;
+    registrationUrl?: string;
+  };
+  authProviderType?:
+    | 'dynamic_discovery'
+    | 'google_credentials'
+    | 'service_account_impersonation';
+  targetAudience?: string;
+  targetServiceAccount?: string;
+}
+
 export interface CLIControlInitializeRequest {
   subtype: 'initialize';
   hooks?: HookRegistration[] | null;
-  sdkMcpServers?: Record<string, MCPServerConfig>;
-  mcpServers?: Record<string, MCPServerConfig>;
+  /**
+   * SDK MCP servers config
+   * These are MCP servers running in the SDK process, connected via control plane.
+   * External MCP servers are configured separately in settings, not via initialization.
+   */
+  sdkMcpServers?: Record<string, Omit<SDKMcpServerConfig, 'instance'>>;
+  /**
+   * External MCP servers that the SDK wants the CLI to manage.
+   * These run outside the SDK process and require CLI-side transport setup.
+   */
+  mcpServers?: Record<string, CLIMcpServerConfig>;
   agents?: SubagentConfig[];
 }
 

packages/cli/src/ui/components/InputPrompt.test.tsx

@@ -1307,7 +1307,7 @@ describe('InputPrompt', () => {
       mockBuffer.text = text;
       mockBuffer.lines = [text];
       mockBuffer.viewportVisualLines = [text];
-      mockBuffer.visualCursor = [0, 8]; // cursor after '👍' (length is 6 + 2 for emoji)
+      mockBuffer.visualCursor = [0, 7]; // cursor after '👍' (emoji is 1 code point, so total is 7)
 
       const { stdout, unmount } = renderWithProviders(
         <InputPrompt {...props} />,

packages/cli/src/ui/components/InputPrompt.tsx

@@ -707,15 +707,20 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
     statusText = t('Accepting edits');
   }
 
+  const borderColor =
+    isShellFocused && !isEmbeddedShellFocused
+      ? (statusColor ?? theme.border.focused)
+      : theme.border.default;
+
   return (
     <>
       <Box
-        borderStyle="round"
-        borderColor={
-          isShellFocused && !isEmbeddedShellFocused
-            ? (statusColor ?? theme.border.focused)
-            : theme.border.default
-        }
+        borderStyle="single"
+        borderTop={true}
+        borderBottom={true}
+        borderLeft={false}
+        borderRight={false}
+        borderColor={borderColor}
         paddingX={1}
       >
         <Text
@@ -829,9 +834,10 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
                 isOnCursorLine &&
                 cursorVisualColAbsolute === cpLen(lineText)
               ) {
+                // Add zero-width space after cursor to prevent Ink from trimming trailing whitespace
                 renderedLine.push(
                   <Text key={`cursor-end-${cursorVisualColAbsolute}`}>
-                    {showCursor ? chalk.inverse(' ') : ' '}
+                    {showCursor ? chalk.inverse(' ') + '\u200B' : ' \u200B'}
                   </Text>,
                 );
               }

packages/cli/src/ui/components/__snapshots__/InputPrompt.test.tsx.snap

@@ -19,39 +19,39 @@ exports[`InputPrompt > command search (Ctrl+R when not in shell) > expands and c
 `;
 
 exports[`InputPrompt > command search (Ctrl+R when not in shell) > renders match window and expanded view (snapshots) > command-search-collapsed-match 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ (r:)  commit                                                                                     │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ (r:)  commit
+────────────────────────────────────────────────────────────────────────────────────────────────────
  git commit -m "feat: add search" in src/app"
 `;
 
 exports[`InputPrompt > command search (Ctrl+R when not in shell) > renders match window and expanded view (snapshots) > command-search-expanded-match 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ (r:)  commit                                                                                     │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ (r:)  commit
+────────────────────────────────────────────────────────────────────────────────────────────────────
  git commit -m "feat: add search" in src/app"
 `;
 
 exports[`InputPrompt > snapshots > should not show inverted cursor when shell is focused 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ >   Type your message or @path/to/file                                                           │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ >   Type your message or @path/to/file
+────────────────────────────────────────────────────────────────────────────────────────────────────"
 `;
 
 exports[`InputPrompt > snapshots > should render correctly in shell mode 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ !   Type your message or @path/to/file                                                           │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ !   Type your message or @path/to/file
+────────────────────────────────────────────────────────────────────────────────────────────────────"
 `;
 
 exports[`InputPrompt > snapshots > should render correctly in yolo mode 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ *   Type your message or @path/to/file                                                           │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ *   Type your message or @path/to/file
+────────────────────────────────────────────────────────────────────────────────────────────────────"
 `;
 
 exports[`InputPrompt > snapshots > should render correctly when accepting edits 1`] = `
-"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ >   Type your message or @path/to/file                                                           │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
+"────────────────────────────────────────────────────────────────────────────────────────────────────
+ >   Type your message or @path/to/file
+────────────────────────────────────────────────────────────────────────────────────────────────────"
 `;

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code-core",
-  "version": "0.4.0",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "description": "Qwen Code Core",
   "repository": {
     "type": "git",

packages/core/src/config/config.test.ts

@@ -63,6 +63,7 @@ vi.mock('../tools/tool-registry', () => {
   ToolRegistryMock.prototype.registerTool = vi.fn();
   ToolRegistryMock.prototype.discoverAllTools = vi.fn();
   ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
+  ToolRegistryMock.prototype.getAllToolNames = vi.fn(() => []);
   ToolRegistryMock.prototype.getTool = vi.fn();
   ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
   return { ToolRegistry: ToolRegistryMock };

packages/core/src/config/config.ts

@@ -46,6 +46,7 @@ import { ExitPlanModeTool } from '../tools/exitPlanMode.js';
 import { GlobTool } from '../tools/glob.js';
 import { GrepTool } from '../tools/grep.js';
 import { LSTool } from '../tools/ls.js';
+import type { SendSdkMcpMessage } from '../tools/mcp-client.js';
 import { MemoryTool, setGeminiMdFilename } from '../tools/memoryTool.js';
 import { ReadFileTool } from '../tools/read-file.js';
 import { ReadManyFilesTool } from '../tools/read-many-files.js';
@@ -239,9 +240,18 @@ export class MCPServerConfig {
     readonly targetAudience?: string,
     /* targetServiceAccount format: <service-account-name>@<project-num>.iam.gserviceaccount.com */
     readonly targetServiceAccount?: string,
+    // SDK MCP server type - 'sdk' indicates server runs in SDK process
+    readonly type?: 'sdk',
   ) {}
 }
 
+/**
+ * Check if an MCP server config represents an SDK server
+ */
+export function isSdkMcpServerConfig(config: MCPServerConfig): boolean {
+  return config.type === 'sdk';
+}
+
 export enum AuthProviderType {
   DYNAMIC_DISCOVERY = 'dynamic_discovery',
   GOOGLE_CREDENTIALS = 'google_credentials',
@@ -360,6 +370,17 @@ function normalizeConfigOutputFormat(
   }
 }
 
+/**
+ * Options for Config.initialize()
+ */
+export interface ConfigInitializeOptions {
+  /**
+   * Callback for sending MCP messages to SDK servers via control plane.
+   * Required for SDK MCP server support in SDK mode.
+   */
+  sendSdkMcpMessage?: SendSdkMcpMessage;
+}
+
 export class Config {
   private sessionId: string;
   private sessionData?: ResumedSessionData;
@@ -599,8 +620,9 @@ export class Config {
 
   /**
    * Must only be called once, throws if called again.
+   * @param options Optional initialization options including sendSdkMcpMessage callback
    */
-  async initialize(): Promise<void> {
+  async initialize(options?: ConfigInitializeOptions): Promise<void> {
     if (this.initialized) {
       throw Error('Config was already initialized');
     }
@@ -619,7 +641,9 @@ export class Config {
       this.subagentManager.loadSessionSubagents(this.sessionSubagents);
     }
 
-    this.toolRegistry = await this.createToolRegistry();
+    this.toolRegistry = await this.createToolRegistry(
+      options?.sendSdkMcpMessage,
+    );
 
     await this.geminiClient.initialize();
 
@@ -1261,8 +1285,14 @@ export class Config {
     return this.subagentManager;
   }
 
-  async createToolRegistry(): Promise<ToolRegistry> {
-    const registry = new ToolRegistry(this, this.eventEmitter);
+  async createToolRegistry(
+    sendSdkMcpMessage?: SendSdkMcpMessage,
+  ): Promise<ToolRegistry> {
+    const registry = new ToolRegistry(
+      this,
+      this.eventEmitter,
+      sendSdkMcpMessage,
+    );
 
     const coreToolsConfig = this.getCoreTools();
     const excludeToolsConfig = this.getExcludeTools();
@@ -1347,6 +1377,7 @@ export class Config {
     }
 
     await registry.discoverAllTools();
+    console.debug('ToolRegistry created', registry.getAllToolNames());
     return registry;
   }
 }

packages/core/src/index.ts

@@ -102,7 +102,9 @@ export * from './tools/shell.js';
 export * from './tools/web-search/index.js';
 export * from './tools/read-many-files.js';
 export * from './tools/mcp-client.js';
+export * from './tools/mcp-client-manager.js';
 export * from './tools/mcp-tool.js';
+export * from './tools/sdk-control-client-transport.js';
 export * from './tools/task.js';
 export * from './tools/todoWrite.js';
 export * from './tools/exitPlanMode.js';

packages/core/src/tools/mcp-client-manager.ts

@@ -5,6 +5,7 @@
  */
 
 import type { Config, MCPServerConfig } from '../config/config.js';
+import { isSdkMcpServerConfig } from '../config/config.js';
 import type { ToolRegistry } from './tool-registry.js';
 import type { PromptRegistry } from '../prompts/prompt-registry.js';
 import {
@@ -12,6 +13,7 @@ import {
   MCPDiscoveryState,
   populateMcpServerCommand,
 } from './mcp-client.js';
+import type { SendSdkMcpMessage } from './mcp-client.js';
 import { getErrorMessage } from '../utils/errors.js';
 import type { EventEmitter } from 'node:events';
 import type { WorkspaceContext } from '../utils/workspaceContext.js';
@@ -31,6 +33,7 @@ export class McpClientManager {
   private readonly workspaceContext: WorkspaceContext;
   private discoveryState: MCPDiscoveryState = MCPDiscoveryState.NOT_STARTED;
   private readonly eventEmitter?: EventEmitter;
+  private readonly sendSdkMcpMessage?: SendSdkMcpMessage;
 
   constructor(
     mcpServers: Record<string, MCPServerConfig>,
@@ -40,6 +43,7 @@ export class McpClientManager {
     debugMode: boolean,
     workspaceContext: WorkspaceContext,
     eventEmitter?: EventEmitter,
+    sendSdkMcpMessage?: SendSdkMcpMessage,
   ) {
     this.mcpServers = mcpServers;
     this.mcpServerCommand = mcpServerCommand;
@@ -48,6 +52,7 @@ export class McpClientManager {
     this.debugMode = debugMode;
     this.workspaceContext = workspaceContext;
     this.eventEmitter = eventEmitter;
+    this.sendSdkMcpMessage = sendSdkMcpMessage;
   }
 
   /**
@@ -71,6 +76,11 @@ export class McpClientManager {
     this.eventEmitter?.emit('mcp-client-update', this.clients);
     const discoveryPromises = Object.entries(servers).map(
       async ([name, config]) => {
+        // For SDK MCP servers, pass the sendSdkMcpMessage callback
+        const sdkCallback = isSdkMcpServerConfig(config)
+          ? this.sendSdkMcpMessage
+          : undefined;
+
         const client = new McpClient(
           name,
           config,
@@ -78,6 +88,7 @@ export class McpClientManager {
           this.promptRegistry,
           this.workspaceContext,
           this.debugMode,
+          sdkCallback,
         );
         this.clients.set(name, client);
 

packages/core/src/tools/mcp-client.ts

@@ -13,6 +13,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import type {
   GetPromptResult,
+  JSONRPCMessage,
   Prompt,
 } from '@modelcontextprotocol/sdk/types.js';
 import {
@@ -22,10 +23,11 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 import { parse } from 'shell-quote';
 import type { Config, MCPServerConfig } from '../config/config.js';
-import { AuthProviderType } from '../config/config.js';
+import { AuthProviderType, isSdkMcpServerConfig } from '../config/config.js';
 import { GoogleCredentialProvider } from '../mcp/google-auth-provider.js';
 import { ServiceAccountImpersonationProvider } from '../mcp/sa-impersonation-provider.js';
 import { DiscoveredMCPTool } from './mcp-tool.js';
+import { SdkControlClientTransport } from './sdk-control-client-transport.js';
 
 import type { FunctionDeclaration } from '@google/genai';
 import { mcpToTool } from '@google/genai';
@@ -42,6 +44,14 @@ import type {
 } from '../utils/workspaceContext.js';
 import type { ToolRegistry } from './tool-registry.js';
 
+/**
+ * Callback type for sending MCP messages to SDK servers via control plane
+ */
+export type SendSdkMcpMessage = (
+  serverName: string,
+  message: JSONRPCMessage,
+) => Promise<JSONRPCMessage>;
+
 export const MCP_DEFAULT_TIMEOUT_MSEC = 10 * 60 * 1000; // default to 10 minutes
 
 export type DiscoveredMCPPrompt = Prompt & {
@@ -92,6 +102,7 @@ export class McpClient {
     private readonly promptRegistry: PromptRegistry,
     private readonly workspaceContext: WorkspaceContext,
     private readonly debugMode: boolean,
+    private readonly sendSdkMcpMessage?: SendSdkMcpMessage,
   ) {
     this.client = new Client({
       name: `qwen-cli-mcp-client-${this.serverName}`,
@@ -189,7 +200,12 @@ export class McpClient {
   }
 
   private async createTransport(): Promise<Transport> {
-    return createTransport(this.serverName, this.serverConfig, this.debugMode);
+    return createTransport(
+      this.serverName,
+      this.serverConfig,
+      this.debugMode,
+      this.sendSdkMcpMessage,
+    );
   }
 
   private async discoverTools(cliConfig: Config): Promise<DiscoveredMCPTool[]> {
@@ -501,6 +517,7 @@ export function populateMcpServerCommand(
  * @param mcpServerName The name identifier for this MCP server
  * @param mcpServerConfig Configuration object containing connection details
  * @param toolRegistry The registry to register discovered tools with
+ * @param sendSdkMcpMessage Optional callback for SDK MCP servers to route messages via control plane.
  * @returns Promise that resolves when discovery is complete
  */
 export async function connectAndDiscover(
@@ -511,6 +528,7 @@ export async function connectAndDiscover(
   debugMode: boolean,
   workspaceContext: WorkspaceContext,
   cliConfig: Config,
+  sendSdkMcpMessage?: SendSdkMcpMessage,
 ): Promise<void> {
   updateMCPServerStatus(mcpServerName, MCPServerStatus.CONNECTING);
 
@@ -521,6 +539,7 @@ export async function connectAndDiscover(
       mcpServerConfig,
       debugMode,
       workspaceContext,
+      sendSdkMcpMessage,
     );
 
     mcpClient.onerror = (error) => {
@@ -744,6 +763,7 @@ export function hasNetworkTransport(config: MCPServerConfig): boolean {
  *
  * @param mcpServerName The name of the MCP server, used for logging and identification.
  * @param mcpServerConfig The configuration specifying how to connect to the server.
+ * @param sendSdkMcpMessage Optional callback for SDK MCP servers to route messages via control plane.
  * @returns A promise that resolves to a connected MCP `Client` instance.
  * @throws An error if the connection fails or the configuration is invalid.
  */
@@ -752,6 +772,7 @@ export async function connectToMcpServer(
   mcpServerConfig: MCPServerConfig,
   debugMode: boolean,
   workspaceContext: WorkspaceContext,
+  sendSdkMcpMessage?: SendSdkMcpMessage,
 ): Promise<Client> {
   const mcpClient = new Client({
     name: 'qwen-code-mcp-client',
@@ -808,6 +829,7 @@ export async function connectToMcpServer(
       mcpServerName,
       mcpServerConfig,
       debugMode,
+      sendSdkMcpMessage,
     );
     try {
       await mcpClient.connect(transport, {
@@ -1172,7 +1194,21 @@ export async function createTransport(
   mcpServerName: string,
   mcpServerConfig: MCPServerConfig,
   debugMode: boolean,
+  sendSdkMcpMessage?: SendSdkMcpMessage,
 ): Promise<Transport> {
+  if (isSdkMcpServerConfig(mcpServerConfig)) {
+    if (!sendSdkMcpMessage) {
+      throw new Error(
+        `SDK MCP server '${mcpServerName}' requires sendSdkMcpMessage callback`,
+      );
+    }
+    return new SdkControlClientTransport({
+      serverName: mcpServerName,
+      sendMcpMessage: sendSdkMcpMessage,
+      debugMode,
+    });
+  }
+
   if (
     mcpServerConfig.authProviderType ===
     AuthProviderType.SERVICE_ACCOUNT_IMPERSONATION

packages/core/src/tools/sdk-control-client-transport.ts

@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * SdkControlClientTransport - MCP Client transport for SDK MCP servers
+ *
+ * This transport enables CLI's MCP client to connect to SDK MCP servers
+ * through the control plane. Messages are routed:
+ *
+ * CLI MCP Client → SdkControlClientTransport → sendMcpMessage() →
+ * control_request (mcp_message) → SDK → control_response → onmessage → CLI
+ *
+ * Unlike StdioClientTransport which spawns a subprocess, this transport
+ * communicates with SDK MCP servers running in the SDK process.
+ */
+
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Callback to send MCP messages to SDK via control plane
+ * Returns the MCP response from the SDK
+ */
+export type SendMcpMessageCallback = (
+  serverName: string,
+  message: JSONRPCMessage,
+) => Promise<JSONRPCMessage>;
+
+export interface SdkControlClientTransportOptions {
+  serverName: string;
+  sendMcpMessage: SendMcpMessageCallback;
+  debugMode?: boolean;
+}
+
+/**
+ * MCP Client Transport for SDK MCP servers
+ *
+ * Implements the @modelcontextprotocol/sdk Transport interface to enable
+ * CLI's MCP client to connect to SDK MCP servers via the control plane.
+ */
+export class SdkControlClientTransport {
+  private serverName: string;
+  private sendMcpMessage: SendMcpMessageCallback;
+  private debugMode: boolean;
+  private started = false;
+
+  // Transport interface callbacks
+  onmessage?: (message: JSONRPCMessage) => void;
+  onerror?: (error: Error) => void;
+  onclose?: () => void;
+
+  constructor(options: SdkControlClientTransportOptions) {
+    this.serverName = options.serverName;
+    this.sendMcpMessage = options.sendMcpMessage;
+    this.debugMode = options.debugMode ?? false;
+  }
+
+  /**
+   * Start the transport
+   * For SDK transport, this just marks it as ready - no subprocess to spawn
+   */
+  async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+
+    this.started = true;
+
+    if (this.debugMode) {
+      console.error(
+        `[SdkControlClientTransport] Started for server '${this.serverName}'`,
+      );
+    }
+  }
+
+  /**
+   * Send a message to the SDK MCP server via control plane
+   *
+   * Routes the message through the control plane and delivers
+   * the response via onmessage callback.
+   */
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this.started) {
+      throw new Error(
+        `SdkControlClientTransport (${this.serverName}) not started. Call start() first.`,
+      );
+    }
+
+    if (this.debugMode) {
+      console.error(
+        `[SdkControlClientTransport] Sending message to '${this.serverName}':`,
+        JSON.stringify(message),
+      );
+    }
+
+    try {
+      // Send message to SDK and wait for response
+      const response = await this.sendMcpMessage(this.serverName, message);
+
+      if (this.debugMode) {
+        console.error(
+          `[SdkControlClientTransport] Received response from '${this.serverName}':`,
+          JSON.stringify(response),
+        );
+      }
+
+      // Deliver response via onmessage callback
+      if (this.onmessage) {
+        this.onmessage(response);
+      }
+    } catch (error) {
+      if (this.debugMode) {
+        console.error(
+          `[SdkControlClientTransport] Error sending to '${this.serverName}':`,
+          error,
+        );
+      }
+
+      if (this.onerror) {
+        this.onerror(error instanceof Error ? error : new Error(String(error)));
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Close the transport
+   */
+  async close(): Promise<void> {
+    if (!this.started) {
+      return;
+    }
+
+    this.started = false;
+
+    if (this.debugMode) {
+      console.error(
+        `[SdkControlClientTransport] Closed for server '${this.serverName}'`,
+      );
+    }
+
+    if (this.onclose) {
+      this.onclose();
+    }
+  }
+
+  /**
+   * Check if transport is started
+   */
+  isStarted(): boolean {
+    return this.started;
+  }
+
+  /**
+   * Get server name
+   */
+  getServerName(): string {
+    return this.serverName;
+  }
+}

packages/core/src/tools/tool-registry.ts

@@ -16,6 +16,7 @@ import type { Config } from '../config/config.js';
 import { spawn } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
 import { connectAndDiscover } from './mcp-client.js';
+import type { SendSdkMcpMessage } from './mcp-client.js';
 import { McpClientManager } from './mcp-client-manager.js';
 import { DiscoveredMCPTool } from './mcp-tool.js';
 import { parse } from 'shell-quote';
@@ -173,7 +174,11 @@ export class ToolRegistry {
   private config: Config;
   private mcpClientManager: McpClientManager;
 
-  constructor(config: Config, eventEmitter?: EventEmitter) {
+  constructor(
+    config: Config,
+    eventEmitter?: EventEmitter,
+    sendSdkMcpMessage?: SendSdkMcpMessage,
+  ) {
     this.config = config;
     this.mcpClientManager = new McpClientManager(
       this.config.getMcpServers() ?? {},
@@ -183,6 +188,7 @@ export class ToolRegistry {
       this.config.getDebugMode(),
       this.config.getWorkspaceContext(),
       eventEmitter,
+      sendSdkMcpMessage,
     );
   }
 

packages/core/src/utils/systemEncoding.test.ts

@@ -391,6 +391,19 @@ describe('Shell Command Processor - Encoding Functions', () => {
       expect(result).toBe('windows-1252');
     });
 
+    it('should prioritize UTF-8 detection over Windows system encoding', () => {
+      mockedOsPlatform.mockReturnValue('win32');
+      mockedExecSync.mockReturnValue('Active code page: 936'); // GBK
+
+      const buffer = Buffer.from('test');
+      // Mock chardet to return UTF-8
+      mockedChardetDetect.mockReturnValue('UTF-8');
+
+      const result = getCachedEncodingForBuffer(buffer);
+
+      expect(result).toBe('utf-8');
+    });
+
     it('should cache null system encoding result', () => {
       // Reset the cache specifically for this test
       resetEncodingCache();

packages/core/src/utils/systemEncoding.ts

@@ -34,6 +34,15 @@ export function getCachedEncodingForBuffer(buffer: Buffer): string {
 
   // If we have a cached system encoding, use it
   if (cachedSystemEncoding) {
+    // If the system encoding is not UTF-8 (e.g. Windows CP936), but the buffer
+    // is detected as UTF-8, prefer UTF-8. This handles tools like 'git' which
+    // often output UTF-8 regardless of the system code page.
+    if (cachedSystemEncoding !== 'utf-8') {
+      const detected = detectEncodingFromBuffer(buffer);
+      if (detected === 'utf-8') {
+        return 'utf-8';
+      }
+    }
     return cachedSystemEncoding;
   }
 

packages/sdk-typescript/README.md

@@ -1,4 +1,4 @@
-# @qwen-code/sdk-typescript
+# @qwen-code/sdk
 
 A minimum experimental TypeScript SDK for programmatic access to Qwen Code.
 
@@ -7,20 +7,20 @@ Feel free to submit a feature request/issue/PR.
 ## Installation
 
 ```bash
-npm install @qwen-code/sdk-typescript
+npm install @qwen-code/sdk
 ```
 
 ## Requirements
 
 - Node.js >= 20.0.0
-- [Qwen Code](https://github.com/QwenLM/qwen-code) installed and accessible in PATH
+- [Qwen Code](https://github.com/QwenLM/qwen-code) >= 0.4.0 (stable) installed and accessible in PATH
 
 > **Note for nvm users**: If you use nvm to manage Node.js versions, the SDK may not be able to auto-detect the Qwen Code executable. You should explicitly set the `pathToQwenExecutable` option to the full path of the `qwen` binary.
 
 ## Quick Start
 
 ```typescript
-import { query } from '@qwen-code/sdk-typescript';
+import { query } from '@qwen-code/sdk';
 
 // Single-turn query
 const result = query({
@@ -59,9 +59,9 @@ Creates a new query session with the Qwen Code.
 | `model`                  | `string`                                       | -                | The AI model to use (e.g., `'qwen-max'`, `'qwen-plus'`, `'qwen-turbo'`). Takes precedence over `OPENAI_MODEL` and `QWEN_MODEL` environment variables.                                                                                                                                                                                                                                                                                                                                 |
 | `pathToQwenExecutable`   | `string`                                       | Auto-detected    | Path to the Qwen Code executable. Supports multiple formats: `'qwen'` (native binary from PATH), `'/path/to/qwen'` (explicit path), `'/path/to/cli.js'` (Node.js bundle), `'node:/path/to/cli.js'` (force Node.js runtime), `'bun:/path/to/cli.js'` (force Bun runtime). If not provided, auto-detects from: `QWEN_CODE_CLI_PATH` env var, `~/.volta/bin/qwen`, `~/.npm-global/bin/qwen`, `/usr/local/bin/qwen`, `~/.local/bin/qwen`, `~/node_modules/.bin/qwen`, `~/.yarn/bin/qwen`. |
 | `permissionMode`         | `'default' \| 'plan' \| 'auto-edit' \| 'yolo'` | `'default'`      | Permission mode controlling tool execution approval. See [Permission Modes](#permission-modes) for details.                                                                                                                                                                                                                                                                                                                                                                           |
-| `canUseTool`             | `CanUseTool`                                   | -                | Custom permission handler for tool execution approval. Invoked when a tool requires confirmation. Must respond within 30 seconds or the request will be auto-denied. See [Custom Permission Handler](#custom-permission-handler).                                                                                                                                                                                                                                                     |
+| `canUseTool`             | `CanUseTool`                                   | -                | Custom permission handler for tool execution approval. Invoked when a tool requires confirmation. Must respond within 60 seconds or the request will be auto-denied. See [Custom Permission Handler](#custom-permission-handler).                                                                                                                                                                                                                                                     |
 | `env`                    | `Record<string, string>`                       | -                | Environment variables to pass to the Qwen Code process. Merged with the current process environment.                                                                                                                                                                                                                                                                                                                                                                                  |
-| `mcpServers`             | `Record<string, ExternalMcpServerConfig>`      | -                | External MCP (Model Context Protocol) servers to connect. Each server is identified by a unique name and configured with `command`, `args`, and `env`.                                                                                                                                                                                                                                                                                                                                |
+| `mcpServers`             | `Record<string, McpServerConfig>`              | -                | MCP (Model Context Protocol) servers to connect. Supports external servers (stdio/SSE/HTTP) and SDK-embedded servers. External servers are configured with transport options like `command`, `args`, `url`, `httpUrl`, etc. SDK servers use `{ type: 'sdk', name: string, instance: Server }`.                                                                                                                                                                                        |
 | `abortController`        | `AbortController`                              | -                | Controller to cancel the query session. Call `abortController.abort()` to terminate the session and cleanup resources.                                                                                                                                                                                                                                                                                                                                                                |
 | `debug`                  | `boolean`                                      | `false`          | Enable debug mode for verbose logging from the CLI process.                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `maxSessionTurns`        | `number`                                       | `-1` (unlimited) | Maximum number of conversation turns before the session automatically terminates. A turn consists of a user message and an assistant response.                                                                                                                                                                                                                                                                                                                                        |
@@ -74,12 +74,27 @@ Creates a new query session with the Qwen Code.
 
 ### Timeouts
 
-The SDK enforces the following timeouts:
+The SDK enforces the following default timeouts:
 
-| Timeout             | Duration   | Description                                                                                                                  |
-| ------------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| Permission Callback | 30 seconds | Maximum time for `canUseTool` callback to respond. If exceeded, the tool request is auto-denied.                             |
-| Control Request     | 30 seconds | Maximum time for control operations like `initialize()`, `setModel()`, `setPermissionMode()`, and `interrupt()` to complete. |
+| Timeout          | Default  | Description                                                                                                                  |
+| ---------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `canUseTool`     | 1 minute | Maximum time for `canUseTool` callback to respond. If exceeded, the tool request is auto-denied.                             |
+| `mcpRequest`     | 1 minute | Maximum time for SDK MCP tool calls to complete.                                                                             |
+| `controlRequest` | 1 minute | Maximum time for control operations like `initialize()`, `setModel()`, `setPermissionMode()`, and `interrupt()` to complete. |
+| `streamClose`    | 1 minute | Maximum time to wait for initialization to complete before closing CLI stdin in multi-turn mode with SDK MCP servers.        |
+
+You can customize these timeouts via the `timeout` option:
+
+```typescript
+const query = qwen.query('Your prompt', {
+  timeout: {
+    canUseTool: 60000, // 60 seconds for permission callback
+    mcpRequest: 600000, // 10 minutes for MCP tool calls
+    controlRequest: 60000, // 60 seconds for control requests
+    streamClose: 15000, // 15 seconds for stream close wait
+  },
+});
+```
 
 ### Message Types
 
@@ -92,7 +107,7 @@ import {
   isSDKSystemMessage,
   isSDKResultMessage,
   isSDKPartialAssistantMessage,
-} from '@qwen-code/sdk-typescript';
+} from '@qwen-code/sdk';
 
 for await (const message of result) {
   if (isSDKAssistantMessage(message)) {
@@ -152,7 +167,7 @@ The SDK supports different permission modes for controlling tool execution:
 ### Multi-turn Conversation
 
 ```typescript
-import { query, type SDKUserMessage } from '@qwen-code/sdk-typescript';
+import { query, type SDKUserMessage } from '@qwen-code/sdk';
 
 async function* generateMessages(): AsyncIterable<SDKUserMessage> {
   yield {
@@ -186,7 +201,7 @@ for await (const message of result) {
 ### Custom Permission Handler
 
 ```typescript
-import { query, type CanUseTool } from '@qwen-code/sdk-typescript';
+import { query, type CanUseTool } from '@qwen-code/sdk';
 
 const canUseTool: CanUseTool = async (toolName, input, { signal }) => {
   // Allow all read operations
@@ -212,10 +227,10 @@ const result = query({
 });
 ```
 
-### With MCP Servers
+### With External MCP Servers
 
 ```typescript
-import { query } from '@qwen-code/sdk-typescript';
+import { query } from '@qwen-code/sdk';
 
 const result = query({
   prompt: 'Use the custom tool from my MCP server',
@@ -231,10 +246,88 @@ const result = query({
 });
 ```
 
+### With SDK-Embedded MCP Servers
+
+The SDK provides `tool` and `createSdkMcpServer` to create MCP servers that run in the same process as your SDK application. This is useful when you want to expose custom tools to the AI without running a separate server process.
+
+#### `tool(name, description, inputSchema, handler)`
+
+Creates a tool definition with Zod schema type inference.
+
+| Parameter     | Type                               | Description                                                              |
+| ------------- | ---------------------------------- | ------------------------------------------------------------------------ |
+| `name`        | `string`                           | Tool name (1-64 chars, starts with letter, alphanumeric and underscores) |
+| `description` | `string`                           | Human-readable description of what the tool does                         |
+| `inputSchema` | `ZodRawShape`                      | Zod schema object defining the tool's input parameters                   |
+| `handler`     | `(args, extra) => Promise<Result>` | Async function that executes the tool and returns MCP content blocks     |
+
+The handler must return a `CallToolResult` object with the following structure:
+
+```typescript
+{
+  content: Array<
+    | { type: 'text'; text: string }
+    | { type: 'image'; data: string; mimeType: string }
+    | { type: 'resource'; uri: string; mimeType?: string; text?: string }
+  >;
+  isError?: boolean;
+}
+```
+
+#### `createSdkMcpServer(options)`
+
+Creates an SDK-embedded MCP server instance.
+
+| Option    | Type                     | Default   | Description                          |
+| --------- | ------------------------ | --------- | ------------------------------------ |
+| `name`    | `string`                 | Required  | Unique name for the MCP server       |
+| `version` | `string`                 | `'1.0.0'` | Server version                       |
+| `tools`   | `SdkMcpToolDefinition[]` | -         | Array of tools created with `tool()` |
+
+Returns a `McpSdkServerConfigWithInstance` object that can be passed directly to the `mcpServers` option.
+
+#### Example
+
+```typescript
+import { z } from 'zod';
+import { query, tool, createSdkMcpServer } from '@qwen-code/sdk';
+
+// Define a tool with Zod schema
+const calculatorTool = tool(
+  'calculate_sum',
+  'Add two numbers',
+  { a: z.number(), b: z.number() },
+  async (args) => ({
+    content: [{ type: 'text', text: String(args.a + args.b) }],
+  }),
+);
+
+// Create the MCP server
+const server = createSdkMcpServer({
+  name: 'calculator',
+  tools: [calculatorTool],
+});
+
+// Use the server in a query
+const result = query({
+  prompt: 'What is 42 + 17?',
+  options: {
+    permissionMode: 'yolo',
+    mcpServers: {
+      calculator: server,
+    },
+  },
+});
+
+for await (const message of result) {
+  console.log(message);
+}
+```
+
 ### Abort a Query
 
 ```typescript
-import { query, isAbortError } from '@qwen-code/sdk-typescript';
+import { query, isAbortError } from '@qwen-code/sdk';
 
 const abortController = new AbortController();
 
@@ -266,7 +359,7 @@ try {
 The SDK provides an `AbortError` class for handling aborted queries:
 
 ```typescript
-import { AbortError, isAbortError } from '@qwen-code/sdk-typescript';
+import { AbortError, isAbortError } from '@qwen-code/sdk';
 
 try {
   // ... query operations

packages/sdk-typescript/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "@qwen-code/sdk-typescript",
-  "version": "0.1.0",
+  "name": "@qwen-code/sdk",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "description": "TypeScript SDK for programmatic access to qwen-code CLI",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

packages/sdk-typescript/scripts/get-release-version.js

@@ -14,7 +14,7 @@ import { dirname, join } from 'node:path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const PACKAGE_NAME = '@qwen-code/sdk-typescript';
+const PACKAGE_NAME = '@qwen-code/sdk';
 const TAG_PREFIX = 'sdk-typescript-v';
 
 function readJson(filePath) {

packages/sdk-typescript/src/index.ts

@@ -3,6 +3,17 @@ export { AbortError, isAbortError } from './types/errors.js';
 export { Query } from './query/Query.js';
 export { SdkLogger } from './utils/logger.js';
 
+// SDK MCP Server exports
+export { tool } from './mcp/tool.js';
+export { createSdkMcpServer } from './mcp/createSdkMcpServer.js';
+
+export type { SdkMcpToolDefinition } from './mcp/tool.js';
+
+export type {
+  CreateSdkMcpServerOptions,
+  McpSdkServerConfigWithInstance,
+} from './mcp/createSdkMcpServer.js';
+
 export type { QueryOptions } from './query/createQuery.js';
 export type { LogLevel, LoggerConfig, ScopedLogger } from './utils/logger.js';
 
@@ -18,6 +29,7 @@ export type {
   SDKResultMessage,
   SDKPartialAssistantMessage,
   SDKMessage,
+  SDKMcpServerConfig,
   ControlMessage,
   CLIControlRequest,
   CLIControlResponse,
@@ -43,6 +55,10 @@ export type {
   PermissionMode,
   CanUseTool,
   PermissionResult,
-  ExternalMcpServerConfig,
-  SdkMcpServerConfig,
+  CLIMcpServerConfig,
+  McpServerConfig,
+  McpOAuthConfig,
+  McpAuthProviderType,
 } from './types/types.js';
+
+export { isSdkMcpServerConfig } from './types/types.js';

packages/sdk-typescript/src/mcp/SdkControlServerTransport.ts

@@ -103,9 +103,3 @@ export class SdkControlServerTransport {
     return this.serverName;
   }
 }
-
-export function createSdkControlServerTransport(
-  options: SdkControlServerTransportOptions,
-): SdkControlServerTransport {
-  return new SdkControlServerTransport(options);
-}

packages/sdk-typescript/src/mcp/createSdkMcpServer.ts

@@ -1,29 +1,63 @@
 /**
- * Factory function to create SDK-embedded MCP servers
- *
- * Creates MCP Server instances that run in the user's Node.js process
- * and are proxied to the CLI via the control plane.
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  type CallToolResultSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import type { ToolDefinition } from '../types/types.js';
-import { formatToolResult, formatToolError } from './formatters.js';
+/**
+ * Factory function to create SDK-embedded MCP servers
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SdkMcpToolDefinition } from './tool.js';
 import { validateToolName } from './tool.js';
-import type { z } from 'zod';
 
-type CallToolResult = z.infer<typeof CallToolResultSchema>;
+/**
+ * Options for creating an SDK MCP server
+ */
+export type CreateSdkMcpServerOptions = {
+  name: string;
+  version?: string;
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  tools?: Array<SdkMcpToolDefinition<any>>;
+};
 
+/**
+ * SDK MCP Server configuration with instance
+ */
+export type McpSdkServerConfigWithInstance = {
+  type: 'sdk';
+  name: string;
+  instance: McpServer;
+};
+
+/**
+ * Creates an MCP server instance that can be used with the SDK transport.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { tool, createSdkMcpServer } from '@qwen-code/sdk';
+ *
+ * const calculatorTool = tool(
+ *   'calculate_sum',
+ *   'Add two numbers',
+ *   { a: z.number(), b: z.number() },
+ *   async (args) => ({ content: [{ type: 'text', text: String(args.a + args.b) }] })
+ * );
+ *
+ * const server = createSdkMcpServer({
+ *   name: 'calculator',
+ *   version: '1.0.0',
+ *   tools: [calculatorTool],
+ * });
+ * ```
+ */
 export function createSdkMcpServer(
-  name: string,
-  version: string,
-  tools: ToolDefinition[],
-): Server {
-  // Validate server name
+  options: CreateSdkMcpServerOptions,
+): McpSdkServerConfigWithInstance {
+  const { name, version = '1.0.0', tools } = options;
+
   if (!name || typeof name !== 'string') {
     throw new Error('MCP server name must be a non-empty string');
   }
@@ -32,78 +66,42 @@ export function createSdkMcpServer(
     throw new Error('MCP server version must be a non-empty string');
   }
 
-  if (!Array.isArray(tools)) {
+  if (tools !== undefined && !Array.isArray(tools)) {
     throw new Error('Tools must be an array');
   }
 
-  // Validate tool names are unique
   const toolNames = new Set<string>();
-  for (const tool of tools) {
-    validateToolName(tool.name);
-
-    if (toolNames.has(tool.name)) {
-      throw new Error(
-        `Duplicate tool name '${tool.name}' in MCP server '${name}'`,
-      );
+  if (tools) {
+    for (const t of tools) {
+      validateToolName(t.name);
+      if (toolNames.has(t.name)) {
+        throw new Error(
+          `Duplicate tool name '${t.name}' in MCP server '${name}'`,
+        );
+      }
+      toolNames.add(t.name);
     }
-    toolNames.add(tool.name);
   }
 
-  // Create MCP Server instance
-  const server = new Server(
-    {
-      name,
-      version,
-    },
+  const server = new McpServer(
+    { name, version },
     {
       capabilities: {
-        tools: {},
+        tools: tools ? {} : undefined,
       },
     },
   );
 
-  // Create tool map for fast lookup
-  const toolMap = new Map<string, ToolDefinition>();
-  for (const tool of tools) {
-    toolMap.set(tool.name, tool);
+  if (tools) {
+    tools.forEach((toolDef) => {
+      server.tool(
+        toolDef.name,
+        toolDef.description,
+        toolDef.inputSchema,
+        toolDef.handler,
+      );
+    });
   }
 
-  // Register list_tools handler
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema,
-    })),
-  }));
-
-  // Register call_tool handler
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name: toolName, arguments: toolArgs } = request.params;
-
-    // Find tool
-    const tool = toolMap.get(toolName);
-    if (!tool) {
-      return formatToolError(
-        new Error(`Tool '${toolName}' not found in server '${name}'`),
-      ) as CallToolResult;
-    }
-
-    try {
-      // Invoke tool handler
-      const result = await tool.handler(toolArgs);
-
-      // Format result
-      return formatToolResult(result) as CallToolResult;
-    } catch (error) {
-      // Handle tool execution error
-      return formatToolError(
-        error instanceof Error
-          ? error
-          : new Error(`Tool '${toolName}' failed: ${String(error)}`),
-      ) as CallToolResult;
-    }
-  });
-
-  return server;
+  return { type: 'sdk', name, instance: server };
 }

packages/sdk-typescript/src/mcp/tool.ts

@@ -1,39 +1,76 @@
 /**
- * Tool definition helper for SDK-embedded MCP servers
- *
- * Provides type-safe tool definitions with generic input/output types.
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { ToolDefinition } from '../types/types.js';
+/**
+ * Tool definition helper for SDK-embedded MCP servers
+ */
 
-export function tool<TInput = unknown, TOutput = unknown>(
-  def: ToolDefinition<TInput, TOutput>,
-): ToolDefinition<TInput, TOutput> {
-  // Validate tool definition
-  if (!def.name || typeof def.name !== 'string') {
-    throw new Error('Tool definition must have a name (string)');
+import type { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import type { z, ZodRawShape, ZodObject, ZodTypeAny } from 'zod';
+
+type CallToolResult = z.infer<typeof CallToolResultSchema>;
+
+/**
+ * SDK MCP Tool Definition with Zod schema type inference
+ */
+export type SdkMcpToolDefinition<Schema extends ZodRawShape = ZodRawShape> = {
+  name: string;
+  description: string;
+  inputSchema: Schema;
+  handler: (
+    args: z.infer<ZodObject<Schema, 'strip', ZodTypeAny>>,
+    extra: unknown,
+  ) => Promise<CallToolResult>;
+};
+
+/**
+ * Create an SDK MCP tool definition with Zod schema inference
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { tool } from '@qwen-code/sdk';
+ *
+ * const calculatorTool = tool(
+ *   'calculate_sum',
+ *   'Calculate the sum of two numbers',
+ *   { a: z.number(), b: z.number() },
+ *   async (args) => {
+ *     // args is inferred as { a: number, b: number }
+ *     return { content: [{ type: 'text', text: String(args.a + args.b) }] };
+ *   }
+ * );
+ * ```
+ */
+export function tool<Schema extends ZodRawShape>(
+  name: string,
+  description: string,
+  inputSchema: Schema,
+  handler: (
+    args: z.infer<ZodObject<Schema, 'strip', ZodTypeAny>>,
+    extra: unknown,
+  ) => Promise<CallToolResult>,
+): SdkMcpToolDefinition<Schema> {
+  if (!name || typeof name !== 'string') {
+    throw new Error('Tool name must be a non-empty string');
   }
 
-  if (!def.description || typeof def.description !== 'string') {
-    throw new Error(
-      `Tool definition for '${def.name}' must have a description (string)`,
-    );
+  if (!description || typeof description !== 'string') {
+    throw new Error(`Tool '${name}' must have a description (string)`);
   }
 
-  if (!def.inputSchema || typeof def.inputSchema !== 'object') {
-    throw new Error(
-      `Tool definition for '${def.name}' must have an inputSchema (object)`,
-    );
+  if (!inputSchema || typeof inputSchema !== 'object') {
+    throw new Error(`Tool '${name}' must have an inputSchema (object)`);
   }
 
-  if (!def.handler || typeof def.handler !== 'function') {
-    throw new Error(
-      `Tool definition for '${def.name}' must have a handler (function)`,
-    );
+  if (!handler || typeof handler !== 'function') {
+    throw new Error(`Tool '${name}' must have a handler (function)`);
   }
 
-  // Return definition (pass-through for type safety)
-  return def;
+  return { name, description, inputSchema, handler };
 }
 
 export function validateToolName(name: string): void {
@@ -53,39 +90,3 @@ export function validateToolName(name: string): void {
     );
   }
 }
-
-export function validateInputSchema(schema: unknown): void {
-  if (!schema || typeof schema !== 'object') {
-    throw new Error('Input schema must be an object');
-  }
-
-  const schemaObj = schema as Record<string, unknown>;
-
-  if (!schemaObj.type) {
-    throw new Error('Input schema must have a type field');
-  }
-
-  // For object schemas, validate properties
-  if (schemaObj.type === 'object') {
-    if (schemaObj.properties && typeof schemaObj.properties !== 'object') {
-      throw new Error('Input schema properties must be an object');
-    }
-
-    if (schemaObj.required && !Array.isArray(schemaObj.required)) {
-      throw new Error('Input schema required must be an array');
-    }
-  }
-}
-
-export function createTool<TInput = unknown, TOutput = unknown>(
-  def: ToolDefinition<TInput, TOutput>,
-): ToolDefinition<TInput, TOutput> {
-  // Validate via tool() function
-  const validated = tool(def);
-
-  // Additional validation
-  validateToolName(validated.name);
-  validateInputSchema(validated.inputSchema);
-
-  return validated;
-}

packages/sdk-typescript/src/query/Query.ts

@@ -5,10 +5,10 @@
  * Implements AsyncIterator protocol for message consumption.
  */
 
-const PERMISSION_CALLBACK_TIMEOUT = 30000;
-const MCP_REQUEST_TIMEOUT = 30000;
-const CONTROL_REQUEST_TIMEOUT = 30000;
-const STREAM_CLOSE_TIMEOUT = 10000;
+const DEFAULT_CAN_USE_TOOL_TIMEOUT = 60_000;
+const DEFAULT_MCP_REQUEST_TIMEOUT = 60_000;
+const DEFAULT_CONTROL_REQUEST_TIMEOUT = 60_000;
+const DEFAULT_STREAM_CLOSE_TIMEOUT = 60_000;
 
 import { randomUUID } from 'node:crypto';
 import { SdkLogger } from '../utils/logger.js';
@@ -19,6 +19,7 @@ import type {
   CLIControlResponse,
   ControlCancelRequest,
   PermissionSuggestion,
+  WireSDKMcpServerConfig,
 } from '../types/protocol.js';
 import {
   isSDKUserMessage,
@@ -31,12 +32,17 @@ import {
   isControlCancel,
 } from '../types/protocol.js';
 import type { Transport } from '../transport/Transport.js';
-import type { QueryOptions } from '../types/types.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { QueryOptions, CLIMcpServerConfig } from '../types/types.js';
+import { isSdkMcpServerConfig } from '../types/types.js';
 import { Stream } from '../utils/Stream.js';
 import { serializeJsonLine } from '../utils/jsonLines.js';
 import { AbortError } from '../types/errors.js';
 import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import type { SdkControlServerTransport } from '../mcp/SdkControlServerTransport.js';
+import {
+  SdkControlServerTransport,
+  type SdkControlServerTransportOptions,
+} from '../mcp/SdkControlServerTransport.js';
 import { ControlRequestType } from '../types/protocol.js';
 
 interface PendingControlRequest {
@@ -46,6 +52,11 @@ interface PendingControlRequest {
   abortController: AbortController;
 }
 
+interface PendingMcpResponse {
+  resolve: (response: JSONRPCMessage) => void;
+  reject: (error: Error) => void;
+}
+
 interface TransportWithEndInput extends Transport {
   endInput(): void;
 }
@@ -61,7 +72,9 @@ export class Query implements AsyncIterable<SDKMessage> {
   private abortController: AbortController;
   private pendingControlRequests: Map<string, PendingControlRequest> =
     new Map();
+  private pendingMcpResponses: Map<string, PendingMcpResponse> = new Map();
   private sdkMcpTransports: Map<string, SdkControlServerTransport> = new Map();
+  private sdkMcpServers: Map<string, McpServer> = new Map();
   readonly initialized: Promise<void>;
   private closed = false;
   private messageRouterStarted = false;
@@ -92,6 +105,11 @@ export class Query implements AsyncIterable<SDKMessage> {
      */
     this.sdkMessages = this.readSdkMessages();
 
+    /**
+     * Promise that resolves when the first SDKResultMessage is received.
+     * Used to coordinate endInput() timing - ensures all initialization
+     * (SDK MCP servers, control responses) is complete before closing CLI stdin.
+     */
     this.firstResultReceivedPromise = new Promise((resolve) => {
       this.firstResultReceivedResolve = resolve;
     });
@@ -121,17 +139,152 @@ export class Query implements AsyncIterable<SDKMessage> {
     this.startMessageRouter();
   }
 
+  private async initializeSdkMcpServers(): Promise<void> {
+    if (!this.options.mcpServers) {
+      return;
+    }
+
+    const connectionPromises: Array<Promise<void>> = [];
+
+    // Extract SDK MCP servers from the unified mcpServers config
+    for (const [key, config] of Object.entries(this.options.mcpServers)) {
+      if (!isSdkMcpServerConfig(config)) {
+        continue; // Skip external MCP servers
+      }
+
+      // Use the name from SDKMcpServerConfig, fallback to key for backwards compatibility
+      const serverName = config.name || key;
+      const server = config.instance;
+
+      // Create transport options with callback to route MCP server responses
+      const transportOptions: SdkControlServerTransportOptions = {
+        sendToQuery: async (message: JSONRPCMessage) => {
+          this.handleMcpServerResponse(serverName, message);
+        },
+        serverName,
+      };
+
+      const sdkTransport = new SdkControlServerTransport(transportOptions);
+
+      // Connect server to transport and only register on success
+      const connectionPromise = server
+        .connect(sdkTransport)
+        .then(() => {
+          // Only add to maps after successful connection
+          this.sdkMcpServers.set(serverName, server);
+          this.sdkMcpTransports.set(serverName, sdkTransport);
+          logger.debug(`SDK MCP server '${serverName}' connected to transport`);
+        })
+        .catch((error) => {
+          logger.error(
+            `Failed to connect SDK MCP server '${serverName}' to transport:`,
+            error,
+          );
+          // Don't throw - one failed server shouldn't prevent others
+        });
+
+      connectionPromises.push(connectionPromise);
+    }
+
+    // Wait for all connection attempts to complete
+    await Promise.all(connectionPromises);
+
+    if (this.sdkMcpServers.size > 0) {
+      logger.info(
+        `Initialized ${this.sdkMcpServers.size} SDK MCP server(s): ${Array.from(this.sdkMcpServers.keys()).join(', ')}`,
+      );
+    }
+  }
+
+  /**
+   * Handle response messages from SDK MCP servers
+   *
+   * When an MCP server sends a response via transport.send(), this callback
+   * routes it back to the pending request that's waiting for it.
+   */
+  private handleMcpServerResponse(
+    serverName: string,
+    message: JSONRPCMessage,
+  ): void {
+    // Check if this is a response with an id
+    if ('id' in message && message.id !== null && message.id !== undefined) {
+      const key = `${serverName}:${message.id}`;
+      const pending = this.pendingMcpResponses.get(key);
+      if (pending) {
+        logger.debug(
+          `Routing MCP response for server '${serverName}', id: ${message.id}`,
+        );
+        pending.resolve(message);
+        this.pendingMcpResponses.delete(key);
+        return;
+      }
+    }
+
+    // If no pending request found, log a warning (this shouldn't happen normally)
+    logger.warn(
+      `Received MCP server response with no pending request: server='${serverName}'`,
+      message,
+    );
+  }
+
+  /**
+   * Get SDK MCP servers config for CLI initialization
+   *
+   * Only SDK servers are sent in the initialize request.
+   */
+  private getSdkMcpServersForCli(): Record<string, WireSDKMcpServerConfig> {
+    const sdkServers: Record<string, WireSDKMcpServerConfig> = {};
+
+    for (const [name] of this.sdkMcpServers.entries()) {
+      sdkServers[name] = { type: 'sdk', name };
+    }
+
+    return sdkServers;
+  }
+
+  /**
+   * Get external MCP servers (non-SDK) that should be managed by the CLI
+   */
+  private getMcpServersForCli(): Record<string, CLIMcpServerConfig> {
+    if (!this.options.mcpServers) {
+      return {};
+    }
+
+    const externalServers: Record<string, CLIMcpServerConfig> = {};
+
+    for (const [name, config] of Object.entries(this.options.mcpServers)) {
+      if (isSdkMcpServerConfig(config)) {
+        continue;
+      }
+      externalServers[name] = config as CLIMcpServerConfig;
+    }
+
+    return externalServers;
+  }
+
   private async initialize(): Promise<void> {
     try {
       logger.debug('Initializing Query');
 
-      const sdkMcpServerNames = Array.from(this.sdkMcpTransports.keys());
+      // Initialize SDK MCP servers and wait for connections
+      await this.initializeSdkMcpServers();
+
+      // Get only successfully connected SDK servers for CLI
+      const sdkMcpServersForCli = this.getSdkMcpServersForCli();
+      const mcpServersForCli = this.getMcpServersForCli();
+      logger.debug('SDK MCP servers for CLI:', sdkMcpServersForCli);
+      logger.debug('External MCP servers for CLI:', mcpServersForCli);
 
       await this.sendControlRequest(ControlRequestType.INITIALIZE, {
         hooks: null,
         sdkMcpServers:
-          sdkMcpServerNames.length > 0 ? sdkMcpServerNames : undefined,
-        mcpServers: this.options.mcpServers,
+          Object.keys(sdkMcpServersForCli).length > 0
+            ? sdkMcpServersForCli
+            : undefined,
+        mcpServers:
+          Object.keys(mcpServersForCli).length > 0
+            ? mcpServersForCli
+            : undefined,
         agents: this.options.agents,
       });
       logger.info('Query initialized successfully');
@@ -279,10 +432,13 @@ export class Query implements AsyncIterable<SDKMessage> {
     }
 
     try {
+      const canUseToolTimeout =
+        this.options.timeout?.canUseTool ?? DEFAULT_CAN_USE_TOOL_TIMEOUT;
+      let timeoutId: NodeJS.Timeout | undefined;
       const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(
+        timeoutId = setTimeout(
           () => reject(new Error('Permission callback timeout')),
-          PERMISSION_CALLBACK_TIMEOUT,
+          canUseToolTimeout,
         );
       });
 
@@ -296,6 +452,10 @@ export class Query implements AsyncIterable<SDKMessage> {
         timeoutPromise,
       ]);
 
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+
       if (result.behavior === 'allow') {
         return {
           behavior: 'allow',
@@ -361,32 +521,45 @@ export class Query implements AsyncIterable<SDKMessage> {
   }
 
   private handleMcpRequest(
-    _serverName: string,
+    serverName: string,
     message: JSONRPCMessage,
     transport: SdkControlServerTransport,
   ): Promise<JSONRPCMessage> {
+    const messageId = 'id' in message ? message.id : null;
+    const key = `${serverName}:${messageId}`;
+
     return new Promise((resolve, reject) => {
+      const mcpRequestTimeout =
+        this.options.timeout?.mcpRequest ?? DEFAULT_MCP_REQUEST_TIMEOUT;
       const timeout = setTimeout(() => {
+        this.pendingMcpResponses.delete(key);
         reject(new Error('MCP request timeout'));
-      }, MCP_REQUEST_TIMEOUT);
+      }, mcpRequestTimeout);
 
-      const messageId = 'id' in message ? message.id : null;
-
-      /**
-       * Hook into transport to capture response.
-       * Temporarily replace sendToQuery to intercept the response message
-       * matching this request's ID, then restore the original handler.
-       */
-      const originalSend = transport.sendToQuery;
-      transport.sendToQuery = async (responseMessage: JSONRPCMessage) => {
-        if ('id' in responseMessage && responseMessage.id === messageId) {
-          clearTimeout(timeout);
-          transport.sendToQuery = originalSend;
-          resolve(responseMessage);
-        }
-        return originalSend(responseMessage);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.pendingMcpResponses.delete(key);
       };
 
+      const resolveAndCleanup = (response: JSONRPCMessage) => {
+        cleanup();
+        resolve(response);
+      };
+
+      const rejectAndCleanup = (error: Error) => {
+        cleanup();
+        reject(error);
+      };
+
+      // Register pending response handler
+      this.pendingMcpResponses.set(key, {
+        resolve: resolveAndCleanup,
+        reject: rejectAndCleanup,
+      });
+
+      // Deliver message to MCP server via transport.onmessage
+      // The server will process it and call transport.send() with the response,
+      // which triggers handleMcpServerResponse to resolve our pending promise
       transport.handleMessage(message);
     });
   }
@@ -452,6 +625,10 @@ export class Query implements AsyncIterable<SDKMessage> {
     subtype: string,
     data: Record<string, unknown> = {},
   ): Promise<Record<string, unknown> | null> {
+    if (this.closed) {
+      return Promise.reject(new Error('Query is closed'));
+    }
+
     const requestId = randomUUID();
 
     const request: CLIControlRequest = {
@@ -466,10 +643,13 @@ export class Query implements AsyncIterable<SDKMessage> {
     const responsePromise = new Promise<Record<string, unknown> | null>(
       (resolve, reject) => {
         const abortController = new AbortController();
+        const controlRequestTimeout =
+          this.options.timeout?.controlRequest ??
+          DEFAULT_CONTROL_REQUEST_TIMEOUT;
         const timeout = setTimeout(() => {
           this.pendingControlRequests.delete(requestId);
           reject(new Error(`Control request timeout: ${subtype}`));
-        }, CONTROL_REQUEST_TIMEOUT);
+        }, controlRequestTimeout);
 
         this.pendingControlRequests.set(requestId, {
           resolve,
@@ -517,9 +697,16 @@ export class Query implements AsyncIterable<SDKMessage> {
     for (const pending of this.pendingControlRequests.values()) {
       pending.abortController.abort();
       clearTimeout(pending.timeout);
+      pending.reject(new Error('Query is closed'));
     }
     this.pendingControlRequests.clear();
 
+    // Clean up pending MCP responses
+    for (const pending of this.pendingMcpResponses.values()) {
+      pending.reject(new Error('Query is closed'));
+    }
+    this.pendingMcpResponses.clear();
+
     await this.transport.close();
 
     /**
@@ -542,7 +729,7 @@ export class Query implements AsyncIterable<SDKMessage> {
       }
     }
     this.sdkMcpTransports.clear();
-    logger.info('Query closed');
+    logger.info('Query is closed');
   }
 
   private async *readSdkMessages(): AsyncGenerator<SDKMessage> {
@@ -588,24 +775,39 @@ export class Query implements AsyncIterable<SDKMessage> {
       }
 
       /**
-       * In multi-turn mode with MCP servers, wait for first result
-       * to ensure MCP servers have time to process before next input.
-       * This prevents race conditions where the next input arrives before
-       * MCP servers have finished processing the current request.
+       * After all user messages are sent (for-await loop ended), determine when to
+       * close the CLI's stdin via endInput().
+       *
+       * - If a result message was already received: All initialization (SDK MCP servers,
+       *   control responses, etc.) is complete, safe to close stdin immediately.
+       * - If no result yet: Wait for either the result to arrive, or the timeout to expire.
+       *   This gives pending control_responses from SDK MCP servers or other modules
+       *   time to complete their initialization before we close the input stream.
+       *
+       * The timeout ensures we don't hang indefinitely - either the turn proceeds
+       * normally, or it fails with a timeout, but Promise.race will always resolve.
        */
       if (
         !this.isSingleTurn &&
         this.sdkMcpTransports.size > 0 &&
         this.firstResultReceivedPromise
       ) {
-        await Promise.race([
-          this.firstResultReceivedPromise,
-          new Promise<void>((resolve) => {
-            setTimeout(() => {
-              resolve();
-            }, STREAM_CLOSE_TIMEOUT);
-          }),
-        ]);
+        const streamCloseTimeout =
+          this.options.timeout?.streamClose ?? DEFAULT_STREAM_CLOSE_TIMEOUT;
+        let timeoutId: NodeJS.Timeout | undefined;
+
+        const timeoutPromise = new Promise<void>((resolve) => {
+          timeoutId = setTimeout(() => {
+            logger.info('streamCloseTimeout resolved');
+            resolve();
+          }, streamCloseTimeout);
+        });
+
+        await Promise.race([this.firstResultReceivedPromise, timeoutPromise]);
+
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
       }
 
       this.endInput();
@@ -635,28 +837,16 @@ export class Query implements AsyncIterable<SDKMessage> {
   }
 
   async interrupt(): Promise<void> {
-    if (this.closed) {
-      throw new Error('Query is closed');
-    }
-
     await this.sendControlRequest(ControlRequestType.INTERRUPT);
   }
 
   async setPermissionMode(mode: string): Promise<void> {
-    if (this.closed) {
-      throw new Error('Query is closed');
-    }
-
     await this.sendControlRequest(ControlRequestType.SET_PERMISSION_MODE, {
       mode,
     });
   }
 
   async setModel(model: string): Promise<void> {
-    if (this.closed) {
-      throw new Error('Query is closed');
-    }
-
     await this.sendControlRequest(ControlRequestType.SET_MODEL, { model });
   }
 
@@ -667,10 +857,6 @@ export class Query implements AsyncIterable<SDKMessage> {
    * @throws Error if query is closed
    */
   async supportedCommands(): Promise<Record<string, unknown> | null> {
-    if (this.closed) {
-      throw new Error('Query is closed');
-    }
-
     return this.sendControlRequest(ControlRequestType.SUPPORTED_COMMANDS);
   }
 
@@ -681,10 +867,6 @@ export class Query implements AsyncIterable<SDKMessage> {
    * @throws Error if query is closed
    */
   async mcpServerStatus(): Promise<Record<string, unknown> | null> {
-    if (this.closed) {
-      throw new Error('Query is closed');
-    }
-
     return this.sendControlRequest(ControlRequestType.MCP_SERVER_STATUS);
   }
 

packages/sdk-typescript/src/types/protocol.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export interface Annotation {
   type: string;
   value: string;
@@ -293,10 +294,44 @@ export interface MCPServerConfig {
   targetServiceAccount?: string;
 }
 
+/**
+ * SDK MCP Server configuration
+ *
+ * SDK MCP servers run in the SDK process and are connected via in-memory transport.
+ * Tool calls are routed through the control plane between SDK and CLI.
+ */
+export interface SDKMcpServerConfig {
+  /**
+   * Type identifier for SDK MCP servers
+   */
+  type: 'sdk';
+  /**
+   * Server name for identification and routing
+   */
+  name: string;
+  /**
+   * The MCP Server instance created by createSdkMcpServer()
+   */
+  instance: McpServer;
+}
+
+/**
+ * Wire format for SDK MCP servers sent to the CLI
+ */
+export type WireSDKMcpServerConfig = Omit<SDKMcpServerConfig, 'instance'>;
+
 export interface CLIControlInitializeRequest {
   subtype: 'initialize';
   hooks?: HookRegistration[] | null;
-  sdkMcpServers?: Record<string, MCPServerConfig>;
+  /**
+   * SDK MCP servers config
+   * These are MCP servers running in the SDK process, connected via control plane.
+   * External MCP servers are configured separately in settings, not via initialization.
+   */
+  sdkMcpServers?: Record<string, WireSDKMcpServerConfig>;
+  /**
+   * External MCP servers that should be managed by the CLI.
+   */
   mcpServers?: Record<string, MCPServerConfig>;
   agents?: SubagentConfig[];
 }

packages/sdk-typescript/src/types/queryOptionsSchema.ts

@@ -2,19 +2,98 @@ import { z } from 'zod';
 import type { CanUseTool } from './types.js';
 import type { SubagentConfig } from './protocol.js';
 
-export const ExternalMcpServerConfigSchema = z.object({
-  command: z.string().min(1, 'Command must be a non-empty string'),
+/**
+ * OAuth configuration for MCP servers
+ */
+export const McpOAuthConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    clientId: z
+      .string()
+      .min(1, 'clientId must be a non-empty string')
+      .optional(),
+    clientSecret: z.string().optional(),
+    scopes: z.array(z.string()).optional(),
+    redirectUri: z.string().optional(),
+    authorizationUrl: z.string().optional(),
+    tokenUrl: z.string().optional(),
+    audiences: z.array(z.string()).optional(),
+    tokenParamName: z.string().optional(),
+    registrationUrl: z.string().optional(),
+  })
+  .strict();
+
+/**
+ * CLI MCP Server configuration schema
+ *
+ * Supports multiple transport types:
+ * - stdio: command, args, env, cwd
+ * - SSE: url
+ * - Streamable HTTP: httpUrl, headers
+ * - WebSocket: tcp
+ */
+export const CLIMcpServerConfigSchema = z.object({
+  // For stdio transport
+  command: z.string().optional(),
   args: z.array(z.string()).optional(),
   env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional(),
+  // For SSE transport
+  url: z.string().optional(),
+  // For streamable HTTP transport
+  httpUrl: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  // For WebSocket transport
+  tcp: z.string().optional(),
+  // Common
+  timeout: z.number().optional(),
+  trust: z.boolean().optional(),
+  // Metadata
+  description: z.string().optional(),
+  includeTools: z.array(z.string()).optional(),
+  excludeTools: z.array(z.string()).optional(),
+  extensionName: z.string().optional(),
+  // OAuth configuration
+  oauth: McpOAuthConfigSchema.optional(),
+  authProviderType: z
+    .enum([
+      'dynamic_discovery',
+      'google_credentials',
+      'service_account_impersonation',
+    ])
+    .optional(),
+  // Service Account Configuration
+  targetAudience: z.string().optional(),
+  targetServiceAccount: z.string().optional(),
 });
 
+/**
+ * SDK MCP Server configuration schema
+ */
 export const SdkMcpServerConfigSchema = z.object({
-  connect: z.custom<(transport: unknown) => Promise<void>>(
-    (val) => typeof val === 'function',
-    { message: 'connect must be a function' },
+  type: z.literal('sdk'),
+  name: z.string().min(1, 'name must be a non-empty string'),
+  instance: z.custom<{
+    connect(transport: unknown): Promise<void>;
+    close(): Promise<void>;
+  }>(
+    (val) =>
+      val &&
+      typeof val === 'object' &&
+      'connect' in val &&
+      typeof val.connect === 'function',
+    { message: 'instance must be an MCP Server with connect method' },
   ),
 });
 
+/**
+ * Unified MCP Server configuration schema
+ */
+export const McpServerConfigSchema = z.union([
+  CLIMcpServerConfigSchema,
+  SdkMcpServerConfigSchema,
+]);
+
 export const ModelConfigSchema = z.object({
   model: z.string().optional(),
   temp: z.number().optional(),
@@ -37,6 +116,13 @@ export const SubagentConfigSchema = z.object({
   isBuiltin: z.boolean().optional(),
 });
 
+export const TimeoutConfigSchema = z.object({
+  canUseTool: z.number().positive().optional(),
+  mcpRequest: z.number().positive().optional(),
+  controlRequest: z.number().positive().optional(),
+  streamClose: z.number().positive().optional(),
+});
+
 export const QueryOptionsSchema = z
   .object({
     cwd: z.string().optional(),
@@ -49,7 +135,7 @@ export const QueryOptionsSchema = z
         message: 'canUseTool must be a function',
       })
       .optional(),
-    mcpServers: z.record(z.string(), ExternalMcpServerConfigSchema).optional(),
+    mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
     abortController: z.instanceof(AbortController).optional(),
     debug: z.boolean().optional(),
     stderr: z
@@ -78,5 +164,6 @@ export const QueryOptionsSchema = z
       )
       .optional(),
     includePartialMessages: z.boolean().optional(),
+    timeout: TimeoutConfigSchema.optional(),
   })
   .strict();

packages/sdk-typescript/src/types/types.ts

@@ -2,25 +2,11 @@ import type {
   PermissionMode,
   PermissionSuggestion,
   SubagentConfig,
+  SDKMcpServerConfig,
 } from './protocol.js';
 
 export type { PermissionMode };
 
-type JSONSchema = {
-  type: string;
-  properties?: Record<string, unknown>;
-  required?: string[];
-  description?: string;
-  [key: string]: unknown;
-};
-
-export type ToolDefinition<TInput = unknown, TOutput = unknown> = {
-  name: string;
-  description: string;
-  inputSchema: JSONSchema;
-  handler: (input: TInput) => Promise<TOutput>;
-};
-
 export type TransportOptions = {
   pathToQwenExecutable: string;
   cwd?: string;
@@ -61,14 +47,115 @@ export type PermissionResult =
       interrupt?: boolean;
     };
 
-export interface ExternalMcpServerConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
+/**
+ * OAuth configuration for MCP servers
+ */
+export interface McpOAuthConfig {
+  enabled?: boolean;
+  clientId?: string;
+  clientSecret?: string;
+  scopes?: string[];
+  redirectUri?: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  audiences?: string[];
+  tokenParamName?: string;
+  registrationUrl?: string;
 }
 
-export interface SdkMcpServerConfig {
-  connect: (transport: unknown) => Promise<void>;
+/**
+ * Auth provider type for MCP servers
+ */
+export type McpAuthProviderType =
+  | 'dynamic_discovery'
+  | 'google_credentials'
+  | 'service_account_impersonation';
+
+/**
+ * CLI MCP Server configuration
+ *
+ * Supports multiple transport types:
+ * - stdio: command, args, env, cwd
+ * - SSE: url
+ * - Streamable HTTP: httpUrl, headers
+ * - WebSocket: tcp
+ *
+ * This interface aligns with MCPServerConfig in @qwen-code/qwen-code-core.
+ */
+export interface CLIMcpServerConfig {
+  // For stdio transport
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  // For SSE transport
+  url?: string;
+  // For streamable HTTP transport
+  httpUrl?: string;
+  headers?: Record<string, string>;
+  // For WebSocket transport
+  tcp?: string;
+  // Common
+  timeout?: number;
+  trust?: boolean;
+  // Metadata
+  description?: string;
+  includeTools?: string[];
+  excludeTools?: string[];
+  extensionName?: string;
+  // OAuth configuration
+  oauth?: McpOAuthConfig;
+  authProviderType?: McpAuthProviderType;
+  // Service Account Configuration
+  /** targetAudience format: CLIENT_ID.apps.googleusercontent.com */
+  targetAudience?: string;
+  /** targetServiceAccount format: <service-account-name>@<project-num>.iam.gserviceaccount.com */
+  targetServiceAccount?: string;
+}
+
+/**
+ * Unified MCP Server configuration
+ *
+ * Supports both external MCP servers (stdio/SSE/HTTP/WebSocket) and SDK-embedded MCP servers.
+ *
+ * @example External MCP server (stdio)
+ * ```typescript
+ * mcpServers: {
+ *   'my-server': { command: 'node', args: ['server.js'] }
+ * }
+ * ```
+ *
+ * @example External MCP server (SSE)
+ * ```typescript
+ * mcpServers: {
+ *   'remote-server': { url: 'http://localhost:3000/sse' }
+ * }
+ * ```
+ *
+ * @example External MCP server (Streamable HTTP)
+ * ```typescript
+ * mcpServers: {
+ *   'http-server': { httpUrl: 'http://localhost:3000/mcp', headers: { 'Authorization': 'Bearer token' } }
+ * }
+ * ```
+ *
+ * @example SDK MCP server
+ * ```typescript
+ * const server = createSdkMcpServer('weather', '1.0.0', [weatherTool]);
+ * mcpServers: {
+ *   'weather': { type: 'sdk', name: 'weather', instance: server }
+ * }
+ * ```
+ */
+export type McpServerConfig = CLIMcpServerConfig | SDKMcpServerConfig;
+
+/**
+ * Type guard to check if a config is an SDK MCP server
+ */
+export function isSdkMcpServerConfig(
+  config: McpServerConfig,
+): config is SDKMcpServerConfig {
+  return 'type' in config && config.type === 'sdk';
 }
 
 /**
@@ -174,11 +261,36 @@ export interface QueryOptions {
   canUseTool?: CanUseTool;
 
   /**
-   * External MCP (Model Context Protocol) servers to connect to.
-   * Each server is identified by a unique name and configured with command, args, and environment.
-   * @example { 'my-server': { command: 'node', args: ['server.js'], env: { PORT: '3000' } } }
+   * MCP (Model Context Protocol) servers to connect to.
+   *
+   * Supports both external MCP servers and SDK-embedded MCP servers:
+   *
+   * **External MCP servers** - Run in separate processes, connected via stdio/SSE/HTTP:
+   * ```typescript
+   * mcpServers: {
+   *   'stdio-server': { command: 'node', args: ['server.js'], env: { PORT: '3000' } },
+   *   'sse-server': { url: 'http://localhost:3000/sse' },
+   *   'http-server': { httpUrl: 'http://localhost:3000/mcp' }
+   * }
+   * ```
+   *
+   * **SDK MCP servers** - Run in the SDK process, connected via in-memory transport:
+   * ```typescript
+   * const myTool = tool({
+   *   name: 'my_tool',
+   *   description: 'My custom tool',
+   *   inputSchema: { type: 'object', properties: { input: { type: 'string' } } },
+   *   handler: async (input) => ({ result: input.input.toUpperCase() }),
+   * });
+   *
+   * const server = createSdkMcpServer('my-server', '1.0.0', [myTool]);
+   *
+   * mcpServers: {
+   *   'my-server': { type: 'sdk', name: 'my-server', instance: server }
+   * }
+   * ```
    */
-  mcpServers?: Record<string, ExternalMcpServerConfig>;
+  mcpServers?: Record<string, McpServerConfig>;
 
   /**
    * AbortController to cancel the query session.
@@ -204,7 +316,7 @@ export interface QueryOptions {
   /**
    * Logging level for the SDK.
    * Controls the verbosity of log messages output by the SDK.
-   * @default 'info'
+   * @default 'error'
    */
   logLevel?: 'debug' | 'info' | 'warn' | 'error';
 
@@ -294,4 +406,43 @@ export interface QueryOptions {
    * @default false
    */
   includePartialMessages?: boolean;
+
+  /**
+   * Timeout configuration for various SDK operations.
+   * All values are in milliseconds.
+   */
+  timeout?: {
+    /**
+     * Timeout for the `canUseTool` callback.
+     * If the callback doesn't resolve within this time, the permission request
+     * will be denied with a timeout error (fail-safe behavior).
+     * @default 60000 (1 minute)
+     */
+    canUseTool?: number;
+
+    /**
+     * Timeout for SDK MCP tool calls.
+     * This applies to tool calls made to SDK-embedded MCP servers.
+     * @default 60000 (1 minute)
+     */
+    mcpRequest?: number;
+
+    /**
+     * Timeout for SDK→CLI control requests.
+     * This applies to internal control operations like initialize, interrupt,
+     * setPermissionMode, setModel, etc.
+     * @default 60000 (1 minute)
+     */
+    controlRequest?: number;
+
+    /**
+     * Timeout for waiting before closing CLI's stdin after user messages are sent.
+     * In multi-turn mode with SDK MCP servers, after all user messages are processed,
+     * the SDK waits for the first result message to ensure all initialization
+     * (control responses, MCP server setup, etc.) is complete before closing stdin.
+     * This timeout is a fallback to avoid hanging indefinitely.
+     * @default 60000 (1 minute)
+     */
+    streamClose?: number;
+  };
 }

packages/sdk-typescript/src/utils/logger.ts

@@ -22,7 +22,7 @@ const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
 
 export class SdkLogger {
   private static config: LoggerConfig = {};
-  private static effectiveLevel: LogLevel = 'info';
+  private static effectiveLevel: LogLevel = 'error';
 
   static configure(config: LoggerConfig): void {
     this.config = config;
@@ -47,7 +47,7 @@ export class SdkLogger {
       return 'debug';
     }
 
-    return 'info';
+    return 'error';
   }
 
   private static isValidLogLevel(level: string): boolean {

packages/sdk-typescript/test/unit/Query.test.ts

@@ -542,13 +542,16 @@ describe('Query', () => {
       const canUseTool = vi.fn().mockImplementation(
         () =>
           new Promise((resolve) => {
-            setTimeout(() => resolve({ behavior: 'allow' }), 35000); // Exceeds 30s timeout
+            setTimeout(() => resolve({ behavior: 'allow' }), 15000);
           }),
       );
 
       const query = new Query(transport, {
         cwd: '/test',
         canUseTool,
+        timeout: {
+          canUseTool: 10000,
+        },
       });
 
       const controlReq = createControlRequest('can_use_tool', 'perm-req-4');
@@ -567,7 +570,7 @@ describe('Query', () => {
             });
           }
         },
-        { timeout: 35000 },
+        { timeout: 15000 },
       );
 
       await query.close();
@@ -1204,7 +1207,12 @@ describe('Query', () => {
     });
 
     it('should handle control request timeout', async () => {
-      const query = new Query(transport, { cwd: '/test' });
+      const query = new Query(transport, {
+        cwd: '/test',
+        timeout: {
+          controlRequest: 10000,
+        },
+      });
 
       // Respond to initialize
       await vi.waitFor(() => {
@@ -1224,7 +1232,7 @@ describe('Query', () => {
       await expect(interruptPromise).rejects.toThrow(/timeout/i);
 
       await query.close();
-    }, 35000);
+    }, 15000);
 
     it('should handle malformed control responses', async () => {
       const query = new Query(transport, { cwd: '/test' });

packages/sdk-typescript/test/unit/createSdkMcpServer.test.ts

@@ -1,3 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 /**
  * Unit tests for createSdkMcpServer
  *
@@ -5,93 +11,112 @@
  */
 
 import { describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
 import { createSdkMcpServer } from '../../src/mcp/createSdkMcpServer.js';
 import { tool } from '../../src/mcp/tool.js';
-import type { ToolDefinition } from '../../src/types/config.js';
+import type { SdkMcpToolDefinition } from '../../src/mcp/tool.js';
 
 describe('createSdkMcpServer', () => {
   describe('Server Creation', () => {
     it('should create server with name and version', () => {
-      const server = createSdkMcpServer('test-server', '1.0.0', []);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [],
+      });
 
       expect(server).toBeDefined();
+      expect(server.type).toBe('sdk');
+      expect(server.name).toBe('test-server');
+      expect(server.instance).toBeDefined();
+    });
+
+    it('should create server with default version', () => {
+      const server = createSdkMcpServer({
+        name: 'test-server',
+      });
+
+      expect(server).toBeDefined();
+      expect(server.name).toBe('test-server');
     });
 
     it('should throw error with invalid name', () => {
-      expect(() => createSdkMcpServer('', '1.0.0', [])).toThrow(
-        'name must be a non-empty string',
+      expect(() => createSdkMcpServer({ name: '', version: '1.0.0' })).toThrow(
+        'MCP server name must be a non-empty string',
       );
     });
 
     it('should throw error with invalid version', () => {
-      expect(() => createSdkMcpServer('test', '', [])).toThrow(
-        'version must be a non-empty string',
+      expect(() => createSdkMcpServer({ name: 'test', version: '' })).toThrow(
+        'MCP server version must be a non-empty string',
       );
     });
 
     it('should throw error with non-array tools', () => {
       expect(() =>
-        createSdkMcpServer('test', '1.0.0', {} as unknown as ToolDefinition[]),
+        createSdkMcpServer({
+          name: 'test',
+          version: '1.0.0',
+          /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+          tools: {} as unknown as SdkMcpToolDefinition<any>[],
+        }),
       ).toThrow('Tools must be an array');
     });
   });
 
   describe('Tool Registration', () => {
     it('should register single tool', () => {
-      const testTool = tool({
-        name: 'test_tool',
-        description: 'A test tool',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            input: { type: 'string' },
-          },
-        },
-        handler: async () => 'result',
-      });
+      const testTool = tool(
+        'test_tool',
+        'A test tool',
+        { input: z.string() },
+        async () => ({
+          content: [{ type: 'text', text: 'result' }],
+        }),
+      );
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [testTool]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [testTool],
+      });
 
       expect(server).toBeDefined();
     });
 
     it('should register multiple tools', () => {
-      const tool1 = tool({
-        name: 'tool1',
-        description: 'Tool 1',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result1',
-      });
+      const tool1 = tool('tool1', 'Tool 1', {}, async () => ({
+        content: [{ type: 'text', text: 'result1' }],
+      }));
 
-      const tool2 = tool({
-        name: 'tool2',
-        description: 'Tool 2',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result2',
-      });
+      const tool2 = tool('tool2', 'Tool 2', {}, async () => ({
+        content: [{ type: 'text', text: 'result2' }],
+      }));
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [tool1, tool2]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [tool1, tool2],
+      });
 
       expect(server).toBeDefined();
     });
 
     it('should throw error for duplicate tool names', () => {
-      const tool1 = tool({
-        name: 'duplicate',
-        description: 'Tool 1',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result1',
-      });
+      const tool1 = tool('duplicate', 'Tool 1', {}, async () => ({
+        content: [{ type: 'text', text: 'result1' }],
+      }));
 
-      const tool2 = tool({
-        name: 'duplicate',
-        description: 'Tool 2',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result2',
-      });
+      const tool2 = tool('duplicate', 'Tool 2', {}, async () => ({
+        content: [{ type: 'text', text: 'result2' }],
+      }));
 
       expect(() =>
-        createSdkMcpServer('test-server', '1.0.0', [tool1, tool2]),
+        createSdkMcpServer({
+          name: 'test-server',
+          version: '1.0.0',
+          tools: [tool1, tool2],
+        }),
       ).toThrow("Duplicate tool name 'duplicate'");
     });
 
@@ -99,36 +124,41 @@ describe('createSdkMcpServer', () => {
       const invalidTool = {
         name: '123invalid', // Starts with number
         description: 'Invalid tool',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result',
+        inputSchema: {},
+        handler: async () => ({
+          content: [{ type: 'text' as const, text: 'result' }],
+        }),
       };
 
       expect(() =>
-        createSdkMcpServer('test-server', '1.0.0', [
-          invalidTool as unknown as ToolDefinition,
-        ]),
+        createSdkMcpServer({
+          name: 'test-server',
+          version: '1.0.0',
+          /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+          tools: [invalidTool as unknown as SdkMcpToolDefinition<any>],
+        }),
       ).toThrow('Tool name');
     });
   });
 
   describe('Tool Handler Invocation', () => {
     it('should invoke tool handler with correct input', async () => {
-      const handler = vi.fn().mockResolvedValue({ result: 'success' });
-
-      const testTool = tool({
-        name: 'test_tool',
-        description: 'A test tool',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            value: { type: 'string' },
-          },
-          required: ['value'],
-        },
-        handler,
+      const handler = vi.fn().mockResolvedValue({
+        content: [{ type: 'text', text: 'success' }],
       });
 
-      createSdkMcpServer('test-server', '1.0.0', [testTool]);
+      const testTool = tool(
+        'test_tool',
+        'A test tool',
+        { value: z.string() },
+        handler,
+      );
+
+      createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [testTool],
+      });
 
       // Note: Actual invocation testing requires MCP SDK integration
       // This test verifies the handler was properly registered
@@ -140,17 +170,18 @@ describe('createSdkMcpServer', () => {
         .fn()
         .mockImplementation(async (input: { value: string }) => {
           await new Promise((resolve) => setTimeout(resolve, 10));
-          return { processed: input.value };
+          return {
+            content: [{ type: 'text', text: `processed: ${input.value}` }],
+          };
         });
 
-      const testTool = tool({
-        name: 'async_tool',
-        description: 'An async tool',
-        inputSchema: { type: 'object' },
-        handler,
-      });
+      const testTool = tool('async_tool', 'An async tool', {}, handler);
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [testTool]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [testTool],
+      });
 
       expect(server).toBeDefined();
     });
@@ -158,40 +189,29 @@ describe('createSdkMcpServer', () => {
 
   describe('Type Safety', () => {
     it('should preserve input type in handler', async () => {
-      type ToolInput = {
-        name: string;
-        age: number;
-      };
-
-      type ToolOutput = {
-        greeting: string;
-      };
-
-      const handler = vi
-        .fn()
-        .mockImplementation(async (input: ToolInput): Promise<ToolOutput> => {
-          return {
-            greeting: `Hello ${input.name}, age ${input.age}`,
-          };
-        });
-
-      const typedTool = tool<ToolInput, ToolOutput>({
-        name: 'typed_tool',
-        description: 'A typed tool',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            age: { type: 'number' },
-          },
-          required: ['name', 'age'],
-        },
-        handler,
+      const handler = vi.fn().mockImplementation(async (input) => {
+        return {
+          content: [
+            { type: 'text', text: `Hello ${input.name}, age ${input.age}` },
+          ],
+        };
       });
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [
-        typedTool as ToolDefinition,
-      ]);
+      const typedTool = tool(
+        'typed_tool',
+        'A typed tool',
+        {
+          name: z.string(),
+          age: z.number(),
+        },
+        handler,
+      );
+
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [typedTool],
+      });
 
       expect(server).toBeDefined();
     });
@@ -201,14 +221,13 @@ describe('createSdkMcpServer', () => {
     it('should handle tool handler errors gracefully', async () => {
       const handler = vi.fn().mockRejectedValue(new Error('Tool failed'));
 
-      const errorTool = tool({
-        name: 'error_tool',
-        description: 'A tool that errors',
-        inputSchema: { type: 'object' },
-        handler,
-      });
+      const errorTool = tool('error_tool', 'A tool that errors', {}, handler);
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [errorTool]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [errorTool],
+      });
 
       expect(server).toBeDefined();
       // Error handling occurs during tool invocation
@@ -219,14 +238,18 @@ describe('createSdkMcpServer', () => {
         throw new Error('Sync error');
       });
 
-      const errorTool = tool({
-        name: 'sync_error_tool',
-        description: 'A tool that errors synchronously',
-        inputSchema: { type: 'object' },
+      const errorTool = tool(
+        'sync_error_tool',
+        'A tool that errors synchronously',
+        {},
         handler,
-      });
+      );
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [errorTool]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [errorTool],
+      });
 
       expect(server).toBeDefined();
     });
@@ -234,69 +257,76 @@ describe('createSdkMcpServer', () => {
 
   describe('Complex Tool Scenarios', () => {
     it('should support tool with complex input schema', () => {
-      const complexTool = tool({
-        name: 'complex_tool',
-        description: 'A tool with complex schema',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            query: { type: 'string' },
-            filters: {
-              type: 'object',
-              properties: {
-                category: { type: 'string' },
-                minPrice: { type: 'number' },
-              },
-            },
-            options: {
-              type: 'array',
-              items: { type: 'string' },
-            },
-          },
-          required: ['query'],
+      const complexTool = tool(
+        'complex_tool',
+        'A tool with complex schema',
+        {
+          query: z.string(),
+          filters: z
+            .object({
+              category: z.string().optional(),
+              minPrice: z.number().optional(),
+            })
+            .optional(),
+          options: z.array(z.string()).optional(),
         },
-        handler: async (input: { filters?: unknown[] }) => {
+        async (input) => {
           return {
-            results: [],
-            filters: input.filters,
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({ results: [], filters: input.filters }),
+              },
+            ],
           };
         },
-      });
+      );
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [
-        complexTool as ToolDefinition,
-      ]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [complexTool],
+      });
 
       expect(server).toBeDefined();
     });
 
     it('should support tool returning complex output', () => {
-      const complexOutputTool = tool({
-        name: 'complex_output_tool',
-        description: 'Returns complex data',
-        inputSchema: { type: 'object' },
-        handler: async () => {
+      const complexOutputTool = tool(
+        'complex_output_tool',
+        'Returns complex data',
+        {},
+        async () => {
           return {
-            data: [
-              { id: 1, name: 'Item 1' },
-              { id: 2, name: 'Item 2' },
-            ],
-            metadata: {
-              total: 2,
-              page: 1,
-            },
-            nested: {
-              deep: {
-                value: 'test',
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  data: [
+                    { id: 1, name: 'Item 1' },
+                    { id: 2, name: 'Item 2' },
+                  ],
+                  metadata: {
+                    total: 2,
+                    page: 1,
+                  },
+                  nested: {
+                    deep: {
+                      value: 'test',
+                    },
+                  },
+                }),
               },
-            },
+            ],
           };
         },
-      });
+      );
 
-      const server = createSdkMcpServer('test-server', '1.0.0', [
-        complexOutputTool,
-      ]);
+      const server = createSdkMcpServer({
+        name: 'test-server',
+        version: '1.0.0',
+        tools: [complexOutputTool],
+      });
 
       expect(server).toBeDefined();
     });
@@ -304,44 +334,50 @@ describe('createSdkMcpServer', () => {
 
   describe('Multiple Servers', () => {
     it('should create multiple independent servers', () => {
-      const tool1 = tool({
-        name: 'tool1',
-        description: 'Tool in server 1',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result1',
-      });
+      const tool1 = tool('tool1', 'Tool in server 1', {}, async () => ({
+        content: [{ type: 'text', text: 'result1' }],
+      }));
 
-      const tool2 = tool({
-        name: 'tool2',
-        description: 'Tool in server 2',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result2',
-      });
+      const tool2 = tool('tool2', 'Tool in server 2', {}, async () => ({
+        content: [{ type: 'text', text: 'result2' }],
+      }));
 
-      const server1 = createSdkMcpServer('server1', '1.0.0', [tool1]);
-      const server2 = createSdkMcpServer('server2', '1.0.0', [tool2]);
+      const server1 = createSdkMcpServer({
+        name: 'server1',
+        version: '1.0.0',
+        tools: [tool1],
+      });
+      const server2 = createSdkMcpServer({
+        name: 'server2',
+        version: '1.0.0',
+        tools: [tool2],
+      });
 
       expect(server1).toBeDefined();
       expect(server2).toBeDefined();
+      expect(server1.name).toBe('server1');
+      expect(server2.name).toBe('server2');
     });
 
     it('should allow same tool name in different servers', () => {
-      const tool1 = tool({
-        name: 'shared_name',
-        description: 'Tool in server 1',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result1',
-      });
+      const tool1 = tool('shared_name', 'Tool in server 1', {}, async () => ({
+        content: [{ type: 'text', text: 'result1' }],
+      }));
 
-      const tool2 = tool({
-        name: 'shared_name',
-        description: 'Tool in server 2',
-        inputSchema: { type: 'object' },
-        handler: async () => 'result2',
-      });
+      const tool2 = tool('shared_name', 'Tool in server 2', {}, async () => ({
+        content: [{ type: 'text', text: 'result2' }],
+      }));
 
-      const server1 = createSdkMcpServer('server1', '1.0.0', [tool1]);
-      const server2 = createSdkMcpServer('server2', '1.0.0', [tool2]);
+      const server1 = createSdkMcpServer({
+        name: 'server1',
+        version: '1.0.0',
+        tools: [tool1],
+      });
+      const server2 = createSdkMcpServer({
+        name: 'server2',
+        version: '1.0.0',
+        tools: [tool2],
+      });
 
       expect(server1).toBeDefined();
       expect(server2).toBeDefined();

packages/test-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code-test-utils",
-  "version": "0.4.0",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "private": true,
   "main": "src/index.ts",
   "license": "Apache-2.0",

packages/vscode-ide-companion/NOTICES.txt

@@ -1,5 +1,26 @@
 This file contains third-party software notices and license terms.
 
+============================================================
+semver@7.7.2
+(git+https://github.com/npm/node-semver.git)
+
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
 ============================================================
 @modelcontextprotocol/sdk@1.15.1
 (git+https://github.com/modelcontextprotocol/typescript-sdk.git)
@@ -2317,3 +2338,520 @@ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+============================================================
+markdown-it@14.1.0
+(No repository found)
+
+Copyright (c) 2014 Vitaly Puzrin, Alex Kocharin.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+
+============================================================
+argparse@2.0.1
+(No repository found)
+
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+============================================================
+entities@4.5.0
+(git://github.com/fb55/entities.git)
+
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+============================================================
+linkify-it@5.0.0
+(No repository found)
+
+Copyright (c) 2015 Vitaly Puzrin.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+
+============================================================
+uc.micro@2.1.0
+(No repository found)
+
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+============================================================
+mdurl@2.0.0
+(No repository found)
+
+Copyright (c) 2015 Vitaly Puzrin, Alex Kocharin.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+.parse() is based on Joyent's node.js `url` code:
+
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+
+============================================================
+punycode.js@2.3.1
+(https://github.com/mathiasbynens/punycode.js.git)
+
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+============================================================
+react@19.1.0
+(https://github.com/facebook/react.git)
+
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+============================================================
+react-dom@19.1.0
+(https://github.com/facebook/react.git)
+
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+============================================================
+scheduler@0.26.0
+(https://github.com/facebook/react.git)
+
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

packages/vscode-ide-companion/README.md

@@ -19,6 +19,63 @@ To use this extension, you'll need:
 - VS Code version 1.101.0 or newer
 - Qwen Code (installed separately) running within the VS Code integrated terminal
 
+# Development and Debugging
+
+To debug and develop this extension locally:
+
+1. **Clone the repository**
+
+   ```bash
+   git clone https://github.com/QwenLM/qwen-code.git
+   cd qwen-code
+   ```
+
+2. **Install dependencies**
+
+   ```bash
+   npm install
+   # or if using pnpm
+   pnpm install
+   ```
+
+3. **Start debugging**
+
+   ```bash
+   code .  # Open the project root in VS Code
+   ```
+   - Open the `packages/vscode-ide-companion/src/extension.ts` file
+   - Open Debug panel (`Ctrl+Shift+D` or `Cmd+Shift+D`)
+   - Select **"Launch Companion VS Code Extension"** from the debug dropdown
+   - Press `F5` to launch Extension Development Host
+
+4. **Make changes and reload**
+   - Edit the source code in the original VS Code window
+   - To see your changes, reload the Extension Development Host window by:
+     - Pressing `Ctrl+R` (Windows/Linux) or `Cmd+R` (macOS)
+     - Or clicking the "Reload" button in the debug toolbar
+
+5. **View logs and debug output**
+   - Open the Debug Console in the original VS Code window to see extension logs
+   - In the Extension Development Host window, open Developer Tools with `Help > Toggle Developer Tools` to see webview logs
+
+## Build for Production
+
+To build the extension for distribution:
+
+```bash
+npm run compile
+# or
+pnpm run compile
+```
+
+To package the extension as a VSIX file:
+
+```bash
+npx vsce package
+# or
+pnpm vsce package
+```
+
 # Terms of Service and Privacy Notice
 
 By installing this extension, you agree to the [Terms of Service](https://github.com/QwenLM/qwen-code/blob/main/docs/tos-privacy.md).

packages/vscode-ide-companion/esbuild.js

@@ -31,8 +31,69 @@ const esbuildProblemMatcherPlugin = {
   },
 };
 
+/**
+ * @type {import('esbuild').Plugin}
+ */
+const cssInjectPlugin = {
+  name: 'css-inject',
+  setup(build) {
+    // Handle CSS files
+    build.onLoad({ filter: /\.css$/ }, async (args) => {
+      const fs = await import('fs');
+      const postcss = (await import('postcss')).default;
+      const tailwindcss = (await import('tailwindcss')).default;
+      const autoprefixer = (await import('autoprefixer')).default;
+
+      let css = await fs.promises.readFile(args.path, 'utf8');
+
+      // For styles.css, we need to resolve @import statements
+      if (args.path.endsWith('styles.css')) {
+        // Read all imported CSS files and inline them
+        const importRegex = /@import\s+'([^']+)';/g;
+        let match;
+        const basePath = args.path.substring(0, args.path.lastIndexOf('/'));
+        while ((match = importRegex.exec(css)) !== null) {
+          const importPath = match[1];
+          // Resolve relative paths correctly
+          let fullPath;
+          if (importPath.startsWith('./')) {
+            fullPath = basePath + importPath.substring(1);
+          } else if (importPath.startsWith('../')) {
+            fullPath = basePath + '/' + importPath;
+          } else {
+            fullPath = basePath + '/' + importPath;
+          }
+
+          try {
+            const importedCss = await fs.promises.readFile(fullPath, 'utf8');
+            css = css.replace(match[0], importedCss);
+          } catch (err) {
+            console.warn(`Could not import ${fullPath}: ${err.message}`);
+          }
+        }
+      }
+
+      // Process with PostCSS (Tailwind + Autoprefixer)
+      const result = await postcss([tailwindcss, autoprefixer]).process(css, {
+        from: args.path,
+        to: args.path,
+      });
+
+      return {
+        contents: `
+          const style = document.createElement('style');
+          style.textContent = ${JSON.stringify(result.css)};
+          document.head.appendChild(style);
+        `,
+        loader: 'js',
+      };
+    });
+  },
+};
+
 async function main() {
-  const ctx = await esbuild.context({
+  // Build extension
+  const extensionCtx = await esbuild.context({
     entryPoints: ['src/extension.ts'],
     bundle: true,
     format: 'cjs',
@@ -55,11 +116,30 @@ async function main() {
     ],
     loader: { '.node': 'file' },
   });
+
+  // Build webview
+  const webviewCtx = await esbuild.context({
+    entryPoints: ['src/webview/index.tsx'],
+    bundle: true,
+    format: 'iife',
+    minify: production,
+    sourcemap: !production,
+    sourcesContent: false,
+    platform: 'browser',
+    outfile: 'dist/webview.js',
+    logLevel: 'silent',
+    plugins: [cssInjectPlugin, esbuildProblemMatcherPlugin],
+    jsx: 'automatic', // Use new JSX transform (React 17+)
+    define: {
+      'process.env.NODE_ENV': production ? '"production"' : '"development"',
+    },
+  });
+
   if (watch) {
-    await ctx.watch();
+    await Promise.all([extensionCtx.watch(), webviewCtx.watch()]);
   } else {
-    await ctx.rebuild();
-    await ctx.dispose();
+    await Promise.all([extensionCtx.rebuild(), webviewCtx.rebuild()]);
+    await Promise.all([extensionCtx.dispose(), webviewCtx.dispose()]);
   }
 }
 

packages/vscode-ide-companion/eslint.config.mjs

@@ -6,20 +6,44 @@
 
 import typescriptEslint from '@typescript-eslint/eslint-plugin';
 import tsParser from '@typescript-eslint/parser';
+import reactHooks from 'eslint-plugin-react-hooks';
+import importPlugin from 'eslint-plugin-import';
 
 export default [
   {
-    files: ['**/*.ts'],
+    files: ['**/*.ts', '**/*.tsx'],
+  },
+  {
+    files: ['**/*.js', '**/*.cjs', '**/*.mjs'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'commonjs',
+      globals: {
+        module: 'readonly',
+        require: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        process: 'readonly',
+        console: 'readonly',
+      },
+    },
   },
   {
     plugins: {
       '@typescript-eslint': typescriptEslint,
+      'react-hooks': reactHooks,
+      import: importPlugin,
     },
 
     languageOptions: {
       parser: tsParser,
       ecmaVersion: 2022,
       sourceType: 'module',
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
     },
 
     rules: {
@@ -30,6 +54,17 @@ export default [
           format: ['camelCase', 'PascalCase'],
         },
       ],
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'error',
+      // Restrict deep imports but allow known-safe exceptions used by the webview
+      // - react-dom/client: required for React 18's createRoot API
+      // - ./styles/**: local CSS modules loaded by the webview
+      'import/no-internal-modules': [
+        'error',
+        {
+          allow: ['react-dom/client', './styles/**'],
+        },
+      ],
 
       curly: 'warn',
       eqeqeq: 'warn',

packages/vscode-ide-companion/package.json

@@ -2,7 +2,7 @@
   "name": "qwen-code-vscode-ide-companion",
   "displayName": "Qwen Code Companion",
   "description": "Enable Qwen Code with direct access to your VS Code workspace.",
-  "version": "0.4.0",
+  "version": "0.4.1-nightly.20251211.a02c4b27",
   "publisher": "qwenlm",
   "icon": "assets/icon.png",
   "repository": {
@@ -54,6 +54,15 @@
       {
         "command": "qwen-code.showNotices",
         "title": "Qwen Code: View Third-Party Notices"
+      },
+      {
+        "command": "qwen-code.openChat",
+        "title": "Qwen Code: Open",
+        "icon": "./assets/icon.png"
+      },
+      {
+        "command": "qwen-code.login",
+        "title": "Qwen Code: Login"
       }
     ],
     "menus": {
@@ -65,6 +74,10 @@
         {
           "command": "qwen.diff.cancel",
           "when": "qwen.diff.isVisible"
+        },
+        {
+          "command": "qwen-code.login",
+          "when": "false"
         }
       ],
       "editor/title": [
@@ -77,6 +90,10 @@
           "command": "qwen.diff.cancel",
           "when": "qwen.diff.isVisible",
           "group": "navigation"
+        },
+        {
+          "command": "qwen-code.openChat",
+          "group": "navigation"
         }
       ]
     },
@@ -115,21 +132,33 @@
   "devDependencies": {
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.3",
+    "@types/markdown-it": "^14.1.2",
     "@types/node": "20.x",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@types/semver": "^7.7.1",
     "@types/vscode": "^1.99.0",
     "@typescript-eslint/eslint-plugin": "^8.31.1",
     "@typescript-eslint/parser": "^8.31.1",
     "@vscode/vsce": "^3.6.0",
+    "autoprefixer": "^10.4.22",
     "esbuild": "^0.25.3",
     "eslint": "^9.25.1",
+    "eslint-plugin-react-hooks": "^5.2.0",
     "npm-run-all2": "^8.0.2",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^3.4.18",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
   "dependencies": {
+    "semver": "^7.7.2",
     "@modelcontextprotocol/sdk": "^1.15.1",
     "cors": "^2.8.5",
     "express": "^5.1.0",
+    "markdown-it": "^14.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
     "zod": "^3.25.76"
   }
 }

packages/vscode-ide-companion/postcss.config.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable no-undef */
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

packages/vscode-ide-companion/src/cli/cliContextManager.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { CliFeatureFlags, CliVersionInfo } from './cliVersionManager.js';
+
+export class CliContextManager {
+  private static instance: CliContextManager;
+  private currentVersionInfo: CliVersionInfo | null = null;
+
+  private constructor() {}
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): CliContextManager {
+    if (!CliContextManager.instance) {
+      CliContextManager.instance = new CliContextManager();
+    }
+    return CliContextManager.instance;
+  }
+
+  /**
+   * Set current CLI version information
+   *
+   * @param versionInfo - CLI version information
+   */
+  setCurrentVersionInfo(versionInfo: CliVersionInfo): void {
+    this.currentVersionInfo = versionInfo;
+  }
+
+  /**
+   * Get current CLI feature flags
+   *
+   * @returns Current CLI feature flags or default flags if not set
+   */
+  getCurrentFeatures(): CliFeatureFlags {
+    if (this.currentVersionInfo) {
+      return this.currentVersionInfo.features;
+    }
+
+    // Return default feature flags (all disabled)
+    return {
+      supportsSessionList: false,
+      supportsSessionLoad: false,
+    };
+  }
+
+  supportsSessionList(): boolean {
+    return this.getCurrentFeatures().supportsSessionList;
+  }
+
+  supportsSessionLoad(): boolean {
+    return this.getCurrentFeatures().supportsSessionLoad;
+  }
+}

packages/vscode-ide-companion/src/cli/cliDetector.ts

@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export interface CliDetectionResult {
+  isInstalled: boolean;
+  cliPath?: string;
+  version?: string;
+  error?: string;
+}
+
+/**
+ * Detects if Qwen Code CLI is installed and accessible
+ */
+export class CliDetector {
+  private static cachedResult: CliDetectionResult | null = null;
+  private static lastCheckTime: number = 0;
+  private static readonly CACHE_DURATION_MS = 30000; // 30 seconds
+
+  /**
+   * Checks if the Qwen Code CLI is installed
+   * @param forceRefresh - Force a new check, ignoring cache
+   * @returns Detection result with installation status and details
+   */
+  static async detectQwenCli(
+    forceRefresh = false,
+  ): Promise<CliDetectionResult> {
+    const now = Date.now();
+
+    // Return cached result if available and not expired
+    if (
+      !forceRefresh &&
+      this.cachedResult &&
+      now - this.lastCheckTime < this.CACHE_DURATION_MS
+    ) {
+      console.log('[CliDetector] Returning cached result');
+      return this.cachedResult;
+    }
+
+    console.log(
+      '[CliDetector] Starting CLI detection, current PATH:',
+      process.env.PATH,
+    );
+
+    try {
+      const isWindows = process.platform === 'win32';
+      const whichCommand = isWindows ? 'where' : 'which';
+
+      // Check if qwen command exists
+      try {
+        // Use NVM environment for consistent detection
+        // Fallback chain: default alias -> node alias -> current version
+        const detectionCommand =
+          process.platform === 'win32'
+            ? `${whichCommand} qwen`
+            : 'source ~/.nvm/nvm.sh 2>/dev/null && (nvm use default 2>/dev/null || nvm use node 2>/dev/null || nvm use 2>/dev/null); which qwen';
+
+        console.log(
+          '[CliDetector] Detecting CLI with command:',
+          detectionCommand,
+        );
+
+        const { stdout } = await execAsync(detectionCommand, {
+          timeout: 5000,
+          shell: '/bin/bash',
+        });
+        // The output may contain multiple lines, with NVM activation messages
+        // We want the last line which should be the actual path
+        const lines = stdout
+          .trim()
+          .split('\n')
+          .filter((line) => line.trim());
+        const cliPath = lines[lines.length - 1];
+
+        console.log('[CliDetector] Found CLI at:', cliPath);
+
+        // Try to get version
+        let version: string | undefined;
+        try {
+          // Use NVM environment for version check
+          // Fallback chain: default alias -> node alias -> current version
+          // Also ensure we use the correct Node.js version that matches the CLI installation
+          const versionCommand =
+            process.platform === 'win32'
+              ? 'qwen --version'
+              : 'source ~/.nvm/nvm.sh 2>/dev/null && (nvm use default 2>/dev/null || nvm use node 2>/dev/null || nvm use 2>/dev/null); qwen --version';
+
+          console.log(
+            '[CliDetector] Getting version with command:',
+            versionCommand,
+          );
+
+          const { stdout: versionOutput } = await execAsync(versionCommand, {
+            timeout: 5000,
+            shell: '/bin/bash',
+          });
+          // The output may contain multiple lines, with NVM activation messages
+          // We want the last line which should be the actual version
+          const versionLines = versionOutput
+            .trim()
+            .split('\n')
+            .filter((line) => line.trim());
+          version = versionLines[versionLines.length - 1];
+          console.log('[CliDetector] CLI version:', version);
+        } catch (versionError) {
+          console.log('[CliDetector] Failed to get CLI version:', versionError);
+          // Version check failed, but CLI is installed
+        }
+
+        this.cachedResult = {
+          isInstalled: true,
+          cliPath,
+          version,
+        };
+        this.lastCheckTime = now;
+        return this.cachedResult;
+      } catch (detectionError) {
+        console.log('[CliDetector] CLI not found, error:', detectionError);
+        // CLI not found
+        let error = `Qwen Code CLI not found in PATH. Please install it using: npm install -g @qwen-code/qwen-code@latest`;
+
+        // Provide specific guidance for permission errors
+        if (detectionError instanceof Error) {
+          const errorMessage = detectionError.message;
+          if (
+            errorMessage.includes('EACCES') ||
+            errorMessage.includes('Permission denied')
+          ) {
+            error += `\n\nThis may be due to permission issues. Possible solutions:
+              \n1. Reinstall the CLI without sudo: npm install -g @qwen-code/qwen-code@latest
+              \n2. If previously installed with sudo, fix ownership: sudo chown -R $(whoami) $(npm config get prefix)/lib/node_modules/@qwen-code/qwen-code
+              \n3. Use nvm for Node.js version management to avoid permission issues
+              \n4. Check your PATH environment variable includes npm's global bin directory`;
+          }
+        }
+
+        this.cachedResult = {
+          isInstalled: false,
+          error,
+        };
+        this.lastCheckTime = now;
+        return this.cachedResult;
+      }
+    } catch (error) {
+      console.log('[CliDetector] General detection error:', error);
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+
+      let userFriendlyError = `Failed to detect Qwen Code CLI: ${errorMessage}`;
+
+      // Provide specific guidance for permission errors
+      if (
+        errorMessage.includes('EACCES') ||
+        errorMessage.includes('Permission denied')
+      ) {
+        userFriendlyError += `\n\nThis may be due to permission issues. Possible solutions:
+          \n1. Reinstall the CLI without sudo: npm install -g @qwen-code/qwen-code@latest
+          \n2. If previously installed with sudo, fix ownership: sudo chown -R $(whoami) $(npm config get prefix)/lib/node_modules/@qwen-code/qwen-code
+          \n3. Use nvm for Node.js version management to avoid permission issues
+          \n4. Check your PATH environment variable includes npm's global bin directory`;
+      }
+
+      this.cachedResult = {
+        isInstalled: false,
+        error: userFriendlyError,
+      };
+      this.lastCheckTime = now;
+      return this.cachedResult;
+    }
+  }
+
+  /**
+   * Clears the cached detection result
+   */
+  static clearCache(): void {
+    this.cachedResult = null;
+    this.lastCheckTime = 0;
+  }
+
+  /**
+   * Gets installation instructions based on the platform
+   */
+  static getInstallationInstructions(): {
+    title: string;
+    steps: string[];
+    documentationUrl: string;
+  } {
+    return {
+      title: 'Qwen Code CLI is not installed',
+      steps: [
+        'Install via npm:',
+        '  npm install -g @qwen-code/qwen-code@latest',
+        '',
+        'If you are using nvm (automatically handled by the plugin):',
+        '  The plugin will automatically use your default nvm version',
+        '',
+        'Or install from source:',
+        '  git clone https://github.com/QwenLM/qwen-code.git',
+        '  cd qwen-code',
+        '  npm install',
+        '  npm install -g .',
+        '',
+        'After installation, reload VS Code or restart the extension.',
+      ],
+      documentationUrl: 'https://github.com/QwenLM/qwen-code#installation',
+    };
+  }
+}

packages/vscode-ide-companion/src/cli/cliInstaller.ts

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import { CliDetector } from './cliDetector.js';
+
+/**
+ * CLI Detection and Installation Handler
+ * Responsible for detecting, installing, and prompting for Qwen CLI
+ */
+export class CliInstaller {
+  /**
+   * Check CLI installation status and send results to WebView
+   * @param sendToWebView Callback function to send messages to WebView
+   */
+  static async checkInstallation(
+    sendToWebView: (message: unknown) => void,
+  ): Promise<void> {
+    try {
+      const result = await CliDetector.detectQwenCli();
+
+      sendToWebView({
+        type: 'cliDetectionResult',
+        data: {
+          isInstalled: result.isInstalled,
+          cliPath: result.cliPath,
+          version: result.version,
+          error: result.error,
+          installInstructions: result.isInstalled
+            ? undefined
+            : CliDetector.getInstallationInstructions(),
+        },
+      });
+
+      if (!result.isInstalled) {
+        console.log('[CliInstaller] Qwen CLI not detected:', result.error);
+      } else {
+        console.log(
+          '[CliInstaller] Qwen CLI detected:',
+          result.cliPath,
+          result.version,
+        );
+      }
+    } catch (error) {
+      console.error('[CliInstaller] CLI detection error:', error);
+    }
+  }
+
+  /**
+   * Prompt user to install CLI
+   * Display warning message with installation options
+   */
+  static async promptInstallation(): Promise<void> {
+    const selection = await vscode.window.showWarningMessage(
+      'Qwen Code CLI is not installed. You can browse conversation history, but cannot send new messages.',
+      'Install Now',
+      'View Documentation',
+      'Remind Me Later',
+    );
+
+    if (selection === 'Install Now') {
+      await this.install();
+    } else if (selection === 'View Documentation') {
+      vscode.env.openExternal(
+        vscode.Uri.parse('https://github.com/QwenLM/qwen-code#installation'),
+      );
+    }
+  }
+
+  /**
+   * Install Qwen CLI
+   * Install global CLI package via npm
+   */
+  static async install(): Promise<void> {
+    try {
+      // Show progress notification
+      await vscode.window.withProgress(
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: 'Installing Qwen Code CLI',
+          cancellable: false,
+        },
+        async (progress) => {
+          progress.report({
+            message: 'Running: npm install -g @qwen-code/qwen-code@latest',
+          });
+
+          const { exec } = await import('child_process');
+          const { promisify } = await import('util');
+          const execAsync = promisify(exec);
+
+          try {
+            // Use NVM environment to ensure we get the same Node.js version
+            // as when they run 'node -v' in terminal
+            // Fallback chain: default alias -> node alias -> current version
+            const installCommand =
+              process.platform === 'win32'
+                ? 'npm install -g @qwen-code/qwen-code@latest'
+                : 'source ~/.nvm/nvm.sh 2>/dev/null && (nvm use default 2>/dev/null || nvm use node 2>/dev/null || nvm use 2>/dev/null); npm install -g @qwen-code/qwen-code@latest';
+
+            console.log(
+              '[CliInstaller] Installing with command:',
+              installCommand,
+            );
+            console.log(
+              '[CliInstaller] Current process PATH:',
+              process.env['PATH'],
+            );
+
+            // Also log Node.js version being used by VS Code
+            console.log(
+              '[CliInstaller] VS Code Node.js version:',
+              process.version,
+            );
+            console.log(
+              '[CliInstaller] VS Code Node.js execPath:',
+              process.execPath,
+            );
+
+            const { stdout, stderr } = await execAsync(
+              installCommand,
+              {
+                timeout: 120000,
+                shell: '/bin/bash',
+              }, // 2 minutes timeout
+            );
+
+            console.log('[CliInstaller] Installation output:', stdout);
+            if (stderr) {
+              console.warn('[CliInstaller] Installation stderr:', stderr);
+            }
+
+            // Clear cache and recheck
+            CliDetector.clearCache();
+            const detection = await CliDetector.detectQwenCli();
+
+            if (detection.isInstalled) {
+              vscode.window
+                .showInformationMessage(
+                  `✅ Qwen Code CLI installed successfully! Version: ${detection.version}`,
+                  'Reload Window',
+                )
+                .then((selection) => {
+                  if (selection === 'Reload Window') {
+                    vscode.commands.executeCommand(
+                      'workbench.action.reloadWindow',
+                    );
+                  }
+                });
+            } else {
+              throw new Error(
+                'Installation completed but CLI still not detected',
+              );
+            }
+          } catch (error) {
+            const errorMessage =
+              error instanceof Error ? error.message : String(error);
+            console.error('[CliInstaller] Installation failed:', errorMessage);
+            console.error('[CliInstaller] Error stack:', error);
+
+            // Provide specific guidance for permission errors
+            let userFriendlyMessage = `Failed to install Qwen Code CLI: ${errorMessage}`;
+
+            if (
+              errorMessage.includes('EACCES') ||
+              errorMessage.includes('Permission denied')
+            ) {
+              userFriendlyMessage += `\n\nThis is likely due to permission issues. Possible solutions:
+                \n1. Reinstall without sudo: npm install -g @qwen-code/qwen-code@latest
+                \n2. Fix npm permissions: sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}
+                \n3. Use nvm for Node.js version management to avoid permission issues
+                \n4. Configure npm to use a different directory: npm config set prefix ~/.npm-global`;
+            }
+
+            vscode.window
+              .showErrorMessage(
+                userFriendlyMessage,
+                'Try Manual Installation',
+                'View Documentation',
+              )
+              .then((selection) => {
+                if (selection === 'Try Manual Installation') {
+                  const terminal = vscode.window.createTerminal(
+                    'Qwen Code Installation',
+                  );
+                  terminal.show();
+
+                  // Provide different installation commands based on error type
+                  if (
+                    errorMessage.includes('EACCES') ||
+                    errorMessage.includes('Permission denied')
+                  ) {
+                    terminal.sendText('# Try installing without sudo:');
+                    terminal.sendText(
+                      'npm install -g @qwen-code/qwen-code@latest',
+                    );
+                    terminal.sendText('');
+                    terminal.sendText('# Or fix npm permissions:');
+                    terminal.sendText(
+                      'sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}',
+                    );
+                  } else {
+                    terminal.sendText(
+                      'npm install -g @qwen-code/qwen-code@latest',
+                    );
+                  }
+                } else if (selection === 'View Documentation') {
+                  vscode.env.openExternal(
+                    vscode.Uri.parse(
+                      'https://github.com/QwenLM/qwen-code#installation',
+                    ),
+                  );
+                }
+              });
+          }
+        },
+      );
+    } catch (error) {
+      console.error('[CliInstaller] Install CLI error:', error);
+    }
+  }
+}

packages/vscode-ide-companion/src/cli/cliPathDetector.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { statSync } from 'fs';
+
+export interface CliPathDetectionResult {
+  path: string | null;
+  error?: string;
+}
+
+/**
+ * Determine the correct Node.js executable path for a given CLI installation
+ * Handles various Node.js version managers (nvm, n, manual installations)
+ *
+ * @param cliPath - Path to the CLI executable
+ * @returns Path to the Node.js executable, or null if not found
+ */
+export function determineNodePathForCli(
+  cliPath: string,
+): CliPathDetectionResult {
+  // Common patterns for Node.js installations
+  const nodePathPatterns = [
+    // NVM pattern: /Users/user/.nvm/versions/node/vXX.XX.X/bin/qwen -> /Users/user/.nvm/versions/node/vXX.XX.X/bin/node
+    cliPath.replace(/\/bin\/qwen$/, '/bin/node'),
+
+    // N pattern: /Users/user/n/bin/qwen -> /Users/user/n/bin/node
+    cliPath.replace(/\/bin\/qwen$/, '/bin/node'),
+
+    // Manual installation pattern: /usr/local/bin/qwen -> /usr/local/bin/node
+    cliPath.replace(/\/qwen$/, '/node'),
+
+    // Alternative pattern: /opt/nodejs/bin/qwen -> /opt/nodejs/bin/node
+    cliPath.replace(/\/bin\/qwen$/, '/bin/node'),
+  ];
+
+  // Check each pattern
+  for (const nodePath of nodePathPatterns) {
+    try {
+      const stats = statSync(nodePath);
+      if (stats.isFile()) {
+        // Verify it's executable
+        if (stats.mode & 0o111) {
+          console.log(`[CLI] Found Node.js executable for CLI at: ${nodePath}`);
+          return { path: nodePath };
+        } else {
+          console.log(`[CLI] Node.js found at ${nodePath} but not executable`);
+          return {
+            path: null,
+            error: `Node.js found at ${nodePath} but not executable. You may need to fix file permissions or reinstall the CLI.`,
+          };
+        }
+      }
+    } catch (error) {
+      // Differentiate between error types
+      if (error instanceof Error) {
+        if ('code' in error && error.code === 'EACCES') {
+          console.log(`[CLI] Permission denied accessing ${nodePath}`);
+          return {
+            path: null,
+            error: `Permission denied accessing ${nodePath}. The CLI may have been installed with sudo privileges. Try reinstalling without sudo or adjusting file permissions.`,
+          };
+        } else if ('code' in error && error.code === 'ENOENT') {
+          // File not found, continue to next pattern
+          continue;
+        } else {
+          console.log(`[CLI] Error accessing ${nodePath}: ${error.message}`);
+          return {
+            path: null,
+            error: `Error accessing Node.js at ${nodePath}: ${error.message}`,
+          };
+        }
+      }
+    }
+  }
+
+  // Try to find node in the same directory as the CLI
+  const cliDir = cliPath.substring(0, cliPath.lastIndexOf('/'));
+  const potentialNodePaths = [`${cliDir}/node`, `${cliDir}/bin/node`];
+
+  for (const nodePath of potentialNodePaths) {
+    try {
+      const stats = statSync(nodePath);
+      if (stats.isFile()) {
+        if (stats.mode & 0o111) {
+          console.log(
+            `[CLI] Found Node.js executable in CLI directory at: ${nodePath}`,
+          );
+          return { path: nodePath };
+        } else {
+          console.log(`[CLI] Node.js found at ${nodePath} but not executable`);
+          return {
+            path: null,
+            error: `Node.js found at ${nodePath} but not executable. You may need to fix file permissions or reinstall the CLI.`,
+          };
+        }
+      }
+    } catch (error) {
+      // Differentiate between error types
+      if (error instanceof Error) {
+        if ('code' in error && error.code === 'EACCES') {
+          console.log(`[CLI] Permission denied accessing ${nodePath}`);
+          return {
+            path: null,
+            error: `Permission denied accessing ${nodePath}. The CLI may have been installed with sudo privileges. Try reinstalling without sudo or adjusting file permissions.`,
+          };
+        } else if ('code' in error && error.code === 'ENOENT') {
+          // File not found, continue
+          continue;
+        } else {
+          console.log(`[CLI] Error accessing ${nodePath}: ${error.message}`);
+          return {
+            path: null,
+            error: `Error accessing Node.js at ${nodePath}: ${error.message}`,
+          };
+        }
+      }
+    }
+  }
+
+  console.log(`[CLI] Could not determine Node.js path for CLI: ${cliPath}`);
+  return {
+    path: null,
+    error: `Could not find Node.js executable for CLI at ${cliPath}. Please verify the CLI installation.`,
+  };
+}

packages/vscode-ide-companion/src/cli/cliVersionManager.ts

@@ -0,0 +1,191 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import semver from 'semver';
+import { CliDetector, type CliDetectionResult } from './cliDetector.js';
+
+export const MIN_CLI_VERSION_FOR_SESSION_METHODS = '0.4.0';
+
+export interface CliFeatureFlags {
+  supportsSessionList: boolean;
+  supportsSessionLoad: boolean;
+}
+
+export interface CliVersionInfo {
+  version: string | undefined;
+  isSupported: boolean;
+  features: CliFeatureFlags;
+  detectionResult: CliDetectionResult;
+}
+
+/**
+ * CLI Version Manager
+ *
+ * Manages CLI version detection and feature availability based on version
+ */
+export class CliVersionManager {
+  private static instance: CliVersionManager;
+  private cachedVersionInfo: CliVersionInfo | null = null;
+  private lastCheckTime: number = 0;
+  private static readonly CACHE_DURATION_MS = 30000; // 30 seconds
+
+  private constructor() {}
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): CliVersionManager {
+    if (!CliVersionManager.instance) {
+      CliVersionManager.instance = new CliVersionManager();
+    }
+    return CliVersionManager.instance;
+  }
+
+  /**
+   * Check if CLI version meets minimum requirements
+   *
+   * @param version - Version string to check
+   * @param minVersion - Minimum required version
+   * @returns Whether version meets requirements
+   */
+  private isVersionSupported(
+    version: string | undefined,
+    minVersion: string,
+  ): boolean {
+    if (!version) {
+      return false;
+    }
+
+    // Use semver for robust comparison (handles v-prefix, pre-release, etc.)
+    const v = semver.valid(version) ?? semver.coerce(version)?.version ?? null;
+    const min =
+      semver.valid(minVersion) ?? semver.coerce(minVersion)?.version ?? null;
+
+    if (!v || !min) {
+      console.warn(
+        `[CliVersionManager] Invalid semver: version=${version}, min=${minVersion}`,
+      );
+      return false;
+    }
+    console.log(`[CliVersionManager] Version ${v} meets requirements: ${min}`);
+    return semver.gte(v, min);
+  }
+
+  /**
+   * Get feature flags based on CLI version
+   *
+   * @param version - CLI version string
+   * @returns Feature flags
+   */
+  private getFeatureFlags(version: string | undefined): CliFeatureFlags {
+    const isSupportedVersion = this.isVersionSupported(
+      version,
+      MIN_CLI_VERSION_FOR_SESSION_METHODS,
+    );
+
+    return {
+      supportsSessionList: isSupportedVersion,
+      supportsSessionLoad: isSupportedVersion,
+    };
+  }
+
+  /**
+   * Detect CLI version and features
+   *
+   * @param forceRefresh - Force a new check, ignoring cache
+   * @returns CLI version information
+   */
+  async detectCliVersion(forceRefresh = false): Promise<CliVersionInfo> {
+    const now = Date.now();
+
+    // Return cached result if available and not expired
+    if (
+      !forceRefresh &&
+      this.cachedVersionInfo &&
+      now - this.lastCheckTime < CliVersionManager.CACHE_DURATION_MS
+    ) {
+      console.log('[CliVersionManager] Returning cached version info');
+      return this.cachedVersionInfo;
+    }
+
+    console.log('[CliVersionManager] Detecting CLI version...');
+
+    try {
+      // Detect CLI installation
+      const detectionResult = await CliDetector.detectQwenCli(forceRefresh);
+
+      const versionInfo: CliVersionInfo = {
+        version: detectionResult.version,
+        isSupported: this.isVersionSupported(
+          detectionResult.version,
+          MIN_CLI_VERSION_FOR_SESSION_METHODS,
+        ),
+        features: this.getFeatureFlags(detectionResult.version),
+        detectionResult,
+      };
+
+      // Cache the result
+      this.cachedVersionInfo = versionInfo;
+      this.lastCheckTime = now;
+
+      console.log(
+        '[CliVersionManager] CLI version detection result:',
+        versionInfo,
+      );
+
+      return versionInfo;
+    } catch (error) {
+      console.error('[CliVersionManager] Failed to detect CLI version:', error);
+
+      // Return fallback result
+      const fallbackResult: CliVersionInfo = {
+        version: undefined,
+        isSupported: false,
+        features: {
+          supportsSessionList: false,
+          supportsSessionLoad: false,
+        },
+        detectionResult: {
+          isInstalled: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+      };
+
+      return fallbackResult;
+    }
+  }
+
+  /**
+   * Clear cached version information
+   */
+  clearCache(): void {
+    this.cachedVersionInfo = null;
+    this.lastCheckTime = 0;
+    CliDetector.clearCache();
+  }
+
+  /**
+   * Check if CLI supports session/list method
+   *
+   * @param forceRefresh - Force a new check, ignoring cache
+   * @returns Whether session/list is supported
+   */
+  async supportsSessionList(forceRefresh = false): Promise<boolean> {
+    const versionInfo = await this.detectCliVersion(forceRefresh);
+    return versionInfo.features.supportsSessionList;
+  }
+
+  /**
+   * Check if CLI supports session/load method
+   *
+   * @param forceRefresh - Force a new check, ignoring cache
+   * @returns Whether session/load is supported
+   */
+  async supportsSessionLoad(forceRefresh = false): Promise<boolean> {
+    const versionInfo = await this.detectCliVersion(forceRefresh);
+    return versionInfo.features.supportsSessionLoad;
+  }
+}

packages/vscode-ide-companion/src/commands/index.ts

@@ -0,0 +1,80 @@
+import * as vscode from 'vscode';
+import type { DiffManager } from '../diff-manager.js';
+import type { WebViewProvider } from '../webview/WebViewProvider.js';
+
+type Logger = (message: string) => void;
+
+export const runQwenCodeCommand = 'qwen-code.runQwenCode';
+export const showDiffCommand = 'qwenCode.showDiff';
+export const openChatCommand = 'qwen-code.openChat';
+export const openNewChatTabCommand = 'qwenCode.openNewChatTab';
+export const loginCommand = 'qwen-code.login';
+
+export function registerNewCommands(
+  context: vscode.ExtensionContext,
+  log: Logger,
+  diffManager: DiffManager,
+  getWebViewProviders: () => WebViewProvider[],
+  createWebViewProvider: () => WebViewProvider,
+): void {
+  const disposables: vscode.Disposable[] = [];
+
+  disposables.push(
+    vscode.commands.registerCommand(openChatCommand, async () => {
+      const providers = getWebViewProviders();
+      if (providers.length > 0) {
+        await providers[providers.length - 1].show();
+      } else {
+        const provider = createWebViewProvider();
+        await provider.show();
+      }
+    }),
+  );
+
+  disposables.push(
+    vscode.commands.registerCommand(
+      showDiffCommand,
+      async (args: { path: string; oldText: string; newText: string }) => {
+        try {
+          let absolutePath = args.path;
+          if (!args.path.startsWith('/') && !args.path.match(/^[a-zA-Z]:/)) {
+            const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+            if (workspaceFolder) {
+              absolutePath = vscode.Uri.joinPath(
+                workspaceFolder.uri,
+                args.path,
+              ).fsPath;
+            }
+          }
+          log(`[Command] Showing diff for ${absolutePath}`);
+          await diffManager.showDiff(absolutePath, args.oldText, args.newText);
+        } catch (error) {
+          log(`[Command] Error showing diff: ${error}`);
+          vscode.window.showErrorMessage(`Failed to show diff: ${error}`);
+        }
+      },
+    ),
+  );
+
+  disposables.push(
+    vscode.commands.registerCommand(openNewChatTabCommand, async () => {
+      const provider = createWebViewProvider();
+      // Session restoration is now disabled by default, so no need to suppress it
+      await provider.show();
+    }),
+  );
+
+  disposables.push(
+    vscode.commands.registerCommand(loginCommand, async () => {
+      const providers = getWebViewProviders();
+      if (providers.length > 0) {
+        await providers[providers.length - 1].forceReLogin();
+      } else {
+        vscode.window.showInformationMessage(
+          'Please open Qwen Code chat first before logging in.',
+        );
+      }
+    }),
+  );
+  context.subscriptions.push(...disposables);
+}

packages/vscode-ide-companion/src/constants/acpSchema.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const AGENT_METHODS = {
+  authenticate: 'authenticate',
+  initialize: 'initialize',
+  session_cancel: 'session/cancel',
+  session_list: 'session/list',
+  session_load: 'session/load',
+  session_new: 'session/new',
+  session_prompt: 'session/prompt',
+  session_save: 'session/save',
+  session_set_mode: 'session/set_mode',
+} as const;
+
+export const CLIENT_METHODS = {
+  fs_read_text_file: 'fs/read_text_file',
+  fs_write_text_file: 'fs/write_text_file',
+  session_request_permission: 'session/request_permission',
+  session_update: 'session/update',
+} as const;

packages/vscode-ide-companion/src/constants/loadingMessages.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Loading messages from Qwen Code CLI
+ * Source: packages/cli/src/ui/hooks/usePhraseCycler.ts
+ */
+export const WITTY_LOADING_PHRASES = [
+  "I'm Feeling Lucky",
+  'Shipping awesomeness... ',
+  'Painting the serifs back on...',
+  'Navigating the slime mold...',
+  'Consulting the digital spirits...',
+  'Reticulating splines...',
+  'Warming up the AI hamsters...',
+  'Asking the magic conch shell...',
+  'Generating witty retort...',
+  'Polishing the algorithms...',
+  "Don't rush perfection (or my code)...",
+  'Brewing fresh bytes...',
+  'Counting electrons...',
+  'Engaging cognitive processors...',
+  'Checking for syntax errors in the universe...',
+  'One moment, optimizing humor...',
+  'Shuffling punchlines...',
+  'Untangling neural nets...',
+  'Compiling brilliance...',
+  'Loading wit.exe...',
+  'Summoning the cloud of wisdom...',
+  'Preparing a witty response...',
+  "Just a sec, I'm debugging reality...",
+  'Confuzzling the options...',
+  'Tuning the cosmic frequencies...',
+  'Crafting a response worthy of your patience...',
+  'Compiling the 1s and 0s...',
+  'Resolving dependencies... and existential crises...',
+  'Defragmenting memories... both RAM and personal...',
+  'Rebooting the humor module...',
+  'Caching the essentials (mostly cat memes)...',
+  'Optimizing for ludicrous speed',
+  "Swapping bits... don't tell the bytes...",
+  'Garbage collecting... be right back...',
+  'Assembling the interwebs...',
+  'Converting coffee into code...',
+  'Updating the syntax for reality...',
+  'Rewiring the synapses...',
+  'Looking for a misplaced semicolon...',
+  "Greasin' the cogs of the machine...",
+  'Pre-heating the servers...',
+  'Calibrating the flux capacitor...',
+  'Engaging the improbability drive...',
+  'Channeling the Force...',
+  'Aligning the stars for optimal response...',
+  'So say we all...',
+  'Loading the next great idea...',
+  "Just a moment, I'm in the zone...",
+  'Preparing to dazzle you with brilliance...',
+  "Just a tick, I'm polishing my wit...",
+  "Hold tight, I'm crafting a masterpiece...",
+  "Just a jiffy, I'm debugging the universe...",
+  "Just a moment, I'm aligning the pixels...",
+  "Just a sec, I'm optimizing the humor...",
+  "Just a moment, I'm tuning the algorithms...",
+  'Warp speed engaged...',
+  'Mining for more Dilithium crystals...',
+  "Don't panic...",
+  'Following the white rabbit...',
+  'The truth is in here... somewhere...',
+  'Blowing on the cartridge...',
+  'Loading... Do a barrel roll!',
+  'Waiting for the respawn...',
+  'Finishing the Kessel Run in less than 12 parsecs...',
+  "The cake is not a lie, it's just still loading...",
+  'Fiddling with the character creation screen...',
+  "Just a moment, I'm finding the right meme...",
+  "Pressing 'A' to continue...",
+  'Herding digital cats...',
+  'Polishing the pixels...',
+  'Finding a suitable loading screen pun...',
+  'Distracting you with this witty phrase...',
+  'Almost there... probably...',
+  'Our hamsters are working as fast as they can...',
+  'Giving Cloudy a pat on the head...',
+  'Petting the cat...',
+  'Rickrolling my boss...',
+  'Never gonna give you up, never gonna let you down...',
+  'Slapping the bass...',
+  'Tasting the snozberries...',
+  "I'm going the distance, I'm going for speed...",
+  'Is this the real life? Is this just fantasy?...',
+  "I've got a good feeling about this...",
+  'Poking the bear...',
+  'Doing research on the latest memes...',
+  'Figuring out how to make this more witty...',
+  'Hmmm... let me think...',
+  'What do you call a fish with no eyes? A fsh...',
+  'Why did the computer go to therapy? It had too many bytes...',
+  "Why don't programmers like nature? It has too many bugs...",
+  'Why do programmers prefer dark mode? Because light attracts bugs...',
+  'Why did the developer go broke? Because they used up all their cache...',
+  "What can you do with a broken pencil? Nothing, it's pointless...",
+  'Applying percussive maintenance...',
+  'Searching for the correct USB orientation...',
+  'Ensuring the magic smoke stays inside the wires...',
+  'Rewriting in Rust for no particular reason...',
+  'Trying to exit Vim...',
+  'Spinning up the hamster wheel...',
+  "That's not a bug, it's an undocumented feature...",
+  'Engage.',
+  "I'll be back... with an answer.",
+  'My other process is a TARDIS...',
+  'Communing with the machine spirit...',
+  'Letting the thoughts marinate...',
+  'Just remembered where I put my keys...',
+  'Pondering the orb...',
+  "I've seen things you people wouldn't believe... like a user who reads loading messages.",
+  'Initiating thoughtful gaze...',
+  "What's a computer's favorite snack? Microchips.",
+  "Why do Java developers wear glasses? Because they don't C#.",
+  'Charging the laser... pew pew!',
+  'Dividing by zero... just kidding!',
+  'Looking for an adult superviso... I mean, processing.',
+  'Making it go beep boop.',
+  'Buffering... because even AIs need a moment.',
+  'Entangling quantum particles for a faster response...',
+  'Polishing the chrome... on the algorithms.',
+  'Are you not entertained? (Working on it!)',
+  'Summoning the code gremlins... to help, of course.',
+  'Just waiting for the dial-up tone to finish...',
+  'Recalibrating the humor-o-meter.',
+  'My other loading screen is even funnier.',
+  "Pretty sure there's a cat walking on the keyboard somewhere...",
+  'Enhancing... Enhancing... Still loading.',
+  "It's not a bug, it's a feature... of this loading screen.",
+  'Have you tried turning it off and on again? (The loading screen, not me.)',
+  'Constructing additional pylons...',
+  "New line? That's Ctrl+J.",
+];
+
+export const getRandomLoadingMessage = (): string =>
+  WITTY_LOADING_PHRASES[
+    Math.floor(Math.random() * WITTY_LOADING_PHRASES.length)
+  ];

packages/vscode-ide-companion/src/diff-manager.ts

@@ -12,6 +12,10 @@ import { type JSONRPCNotification } from '@modelcontextprotocol/sdk/types.js';
 import * as path from 'node:path';
 import * as vscode from 'vscode';
 import { DIFF_SCHEME } from './extension.js';
+import {
+  findLeftGroupOfChatWebview,
+  ensureLeftGroupOfChatWebview,
+} from './utils/editorGroupUtils.js';
 
 export class DiffContentProvider implements vscode.TextDocumentContentProvider {
   private content = new Map<string, string>();
@@ -42,7 +46,9 @@ export class DiffContentProvider implements vscode.TextDocumentContentProvider {
 // Information about a diff view that is currently open.
 interface DiffInfo {
   originalFilePath: string;
+  oldContent: string;
   newContent: string;
+  leftDocUri: vscode.Uri;
   rightDocUri: vscode.Uri;
 }
 
@@ -55,11 +61,26 @@ export class DiffManager {
   readonly onDidChange = this.onDidChangeEmitter.event;
   private diffDocuments = new Map<string, DiffInfo>();
   private readonly subscriptions: vscode.Disposable[] = [];
+  // Dedupe: remember recent showDiff calls keyed by (file+content)
+  private recentlyShown = new Map<string, number>();
+  private pendingDelayTimers = new Map<string, NodeJS.Timeout>();
+  private static readonly DEDUPE_WINDOW_MS = 1500;
+  // Optional hooks from extension to influence diff behavior
+  // - shouldDelay: when true, we defer opening diffs briefly (e.g., while a permission drawer is open)
+  // - shouldSuppress: when true, we skip opening diffs entirely (e.g., in auto/yolo mode)
+  private shouldDelay?: () => boolean;
+  private shouldSuppress?: () => boolean;
+  // Timed suppression window (e.g. immediately after permission allow)
+  private suppressUntil: number | null = null;
 
   constructor(
     private readonly log: (message: string) => void,
     private readonly diffContentProvider: DiffContentProvider,
+    shouldDelay?: () => boolean,
+    shouldSuppress?: () => boolean,
   ) {
+    this.shouldDelay = shouldDelay;
+    this.shouldSuppress = shouldSuppress;
     this.subscriptions.push(
       vscode.window.onDidChangeActiveTextEditor((editor) => {
         this.onActiveEditorChange(editor);
@@ -75,43 +96,142 @@ export class DiffManager {
   }
 
   /**
-   * Creates and shows a new diff view.
+   * Checks if a diff view already exists for the given file path and content
+   * @param filePath Path to the file being diffed
+   * @param oldContent The original content (left side)
+   * @param newContent The modified content (right side)
+   * @returns True if a diff view with the same content already exists, false otherwise
    */
-  async showDiff(filePath: string, newContent: string) {
-    const fileUri = vscode.Uri.file(filePath);
+  private hasExistingDiff(
+    filePath: string,
+    oldContent: string,
+    newContent: string,
+  ): boolean {
+    for (const diffInfo of this.diffDocuments.values()) {
+      if (
+        diffInfo.originalFilePath === filePath &&
+        diffInfo.oldContent === oldContent &&
+        diffInfo.newContent === newContent
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
 
+  /**
+   * Finds an existing diff view for the given file path and focuses it
+   * @param filePath Path to the file being diffed
+   * @returns True if an existing diff view was found and focused, false otherwise
+   */
+  private async focusExistingDiff(filePath: string): Promise<boolean> {
+    const normalizedPath = path.normalize(filePath);
+    for (const [, diffInfo] of this.diffDocuments.entries()) {
+      if (diffInfo.originalFilePath === normalizedPath) {
+        const rightDocUri = diffInfo.rightDocUri;
+        const leftDocUri = diffInfo.leftDocUri;
+
+        const diffTitle = `${path.basename(filePath)} (Before ↔ After)`;
+
+        try {
+          await vscode.commands.executeCommand(
+            'vscode.diff',
+            leftDocUri,
+            rightDocUri,
+            diffTitle,
+            {
+              viewColumn: vscode.ViewColumn.Beside,
+              preview: false,
+              preserveFocus: true,
+            },
+          );
+          return true;
+        } catch (error) {
+          this.log(`Failed to focus existing diff: ${error}`);
+          return false;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Creates and shows a new diff view.
+   * - Overload 1: showDiff(filePath, newContent)
+   * - Overload 2: showDiff(filePath, oldContent, newContent)
+   * If only newContent is provided, the old content will be read from the
+   * filesystem (empty string when file does not exist).
+   */
+  async showDiff(filePath: string, newContent: string): Promise<void>;
+  async showDiff(
+    filePath: string,
+    oldContent: string,
+    newContent: string,
+  ): Promise<void>;
+  async showDiff(filePath: string, a: string, b?: string): Promise<void> {
+    const haveOld = typeof b === 'string';
+    const oldContent = haveOld ? a : await this.readOldContentFromFs(filePath);
+    const newContent = haveOld ? (b as string) : a;
+    const normalizedPath = path.normalize(filePath);
+    const key = this.makeKey(normalizedPath, oldContent, newContent);
+
+    // Check if a diff view with the same content already exists
+    if (this.hasExistingDiff(normalizedPath, oldContent, newContent)) {
+      const last = this.recentlyShown.get(key) || 0;
+      const now = Date.now();
+      if (now - last < DiffManager.DEDUPE_WINDOW_MS) {
+        // Within dedupe window: ignore the duplicate request entirely
+        this.log(
+          `Duplicate showDiff suppressed for ${filePath} (within ${DiffManager.DEDUPE_WINDOW_MS}ms)`,
+        );
+        return;
+      }
+      // Outside the dedupe window: softly focus the existing diff
+      await this.focusExistingDiff(normalizedPath);
+      this.recentlyShown.set(key, now);
+      return;
+    }
+    // Left side: old content using qwen-diff scheme
+    const leftDocUri = vscode.Uri.from({
+      scheme: DIFF_SCHEME,
+      path: normalizedPath,
+      query: `old&rand=${Math.random()}`,
+    });
+    this.diffContentProvider.setContent(leftDocUri, oldContent);
+
+    // Right side: new content using qwen-diff scheme
     const rightDocUri = vscode.Uri.from({
       scheme: DIFF_SCHEME,
-      path: filePath,
-      // cache busting
-      query: `rand=${Math.random()}`,
+      path: normalizedPath,
+      query: `new&rand=${Math.random()}`,
     });
     this.diffContentProvider.setContent(rightDocUri, newContent);
 
     this.addDiffDocument(rightDocUri, {
-      originalFilePath: filePath,
+      originalFilePath: normalizedPath,
+      oldContent,
       newContent,
+      leftDocUri,
       rightDocUri,
     });
 
-    const diffTitle = `${path.basename(filePath)} ↔ Modified`;
+    const diffTitle = `${path.basename(normalizedPath)} (Before ↔ After)`;
     await vscode.commands.executeCommand(
       'setContext',
       'qwen.diff.isVisible',
       true,
     );
 
-    let leftDocUri;
-    try {
-      await vscode.workspace.fs.stat(fileUri);
-      leftDocUri = fileUri;
-    } catch {
-      // We need to provide an empty document to diff against.
-      // Using the 'untitled' scheme is one way to do this.
-      leftDocUri = vscode.Uri.from({
-        scheme: 'untitled',
-        path: filePath,
-      });
+    // Prefer opening the diff adjacent to the chat webview (so we don't
+    // replace content inside the locked webview group). We try the group to
+    // the left of the chat webview first; if none exists we fall back to
+    // ViewColumn.Beside. With the chat locked in the leftmost group, this
+    // fallback opens diffs to the right of the chat.
+    let targetViewColumn = findLeftGroupOfChatWebview();
+    if (targetViewColumn === undefined) {
+      // If there is no left neighbor, create one to satisfy the requirement of
+      // opening diffs to the left of the chat webview.
+      targetViewColumn = await ensureLeftGroupOfChatWebview();
     }
 
     await vscode.commands.executeCommand(
@@ -120,6 +240,10 @@ export class DiffManager {
       rightDocUri,
       diffTitle,
       {
+        // If a left-of-webview group was found, target it explicitly so the
+        // diff opens there while keeping focus on the webview. Otherwise, use
+        // the default "open to side" behavior.
+        viewColumn: targetViewColumn ?? vscode.ViewColumn.Beside,
         preview: false,
         preserveFocus: true,
       },
@@ -127,16 +251,19 @@ export class DiffManager {
     await vscode.commands.executeCommand(
       'workbench.action.files.setActiveEditorWriteableInSession',
     );
+
+    this.recentlyShown.set(key, Date.now());
   }
 
   /**
    * Closes an open diff view for a specific file.
    */
   async closeDiff(filePath: string, suppressNotification = false) {
+    const normalizedPath = path.normalize(filePath);
     let uriToClose: vscode.Uri | undefined;
-    for (const [uriString, diffInfo] of this.diffDocuments.entries()) {
-      if (diffInfo.originalFilePath === filePath) {
-        uriToClose = vscode.Uri.parse(uriString);
+    for (const [, diffInfo] of this.diffDocuments.entries()) {
+      if (diffInfo.originalFilePath === normalizedPath) {
+        uriToClose = diffInfo.rightDocUri;
         break;
       }
     }
@@ -267,4 +394,40 @@ export class DiffManager {
       }
     }
   }
+
+  /** Close all open qwen-diff editors */
+  async closeAll(): Promise<void> {
+    // Collect keys first to avoid iterator invalidation while closing
+    const uris = Array.from(this.diffDocuments.keys()).map((k) =>
+      vscode.Uri.parse(k),
+    );
+    for (const uri of uris) {
+      try {
+        await this.closeDiffEditor(uri);
+      } catch (err) {
+        this.log(`Failed to close diff editor: ${err}`);
+      }
+    }
+  }
+
+  // Read the current content of file from the workspace; return empty string if not found
+  private async readOldContentFromFs(filePath: string): Promise<string> {
+    try {
+      const fileUri = vscode.Uri.file(filePath);
+      const document = await vscode.workspace.openTextDocument(fileUri);
+      return document.getText();
+    } catch {
+      return '';
+    }
+  }
+
+  private makeKey(filePath: string, oldContent: string, newContent: string) {
+    // Simple stable key; content could be large but kept transiently
+    return `${filePath}\u241F${oldContent}\u241F${newContent}`;
+  }
+
+  /** Temporarily suppress opening diffs for a short duration. */
+  suppressFor(durationMs: number): void {
+    this.suppressUntil = Date.now() + Math.max(0, durationMs);
+  }
 }

packages/vscode-ide-companion/src/extension.test.ts

@@ -40,6 +40,9 @@ vi.mock('vscode', () => ({
     },
     showTextDocument: vi.fn(),
     showWorkspaceFolderPick: vi.fn(),
+    registerWebviewPanelSerializer: vi.fn(() => ({
+      dispose: vi.fn(),
+    })),
   },
   workspace: {
     workspaceFolders: [],

packages/vscode-ide-companion/src/extension.ts

@@ -14,6 +14,8 @@ import {
   IDE_DEFINITIONS,
   type IdeInfo,
 } from '@qwen-code/qwen-code-core/src/ide/detect-ide.js';
+import { WebViewProvider } from './webview/WebViewProvider.js';
+import { registerNewCommands } from './commands/index.js';
 
 const CLI_IDE_COMPANION_IDENTIFIER = 'qwenlm.qwen-code-vscode-ide-companion';
 const INFO_MESSAGE_SHOWN_KEY = 'qwenCodeInfoMessageShown';
@@ -31,6 +33,7 @@ const HIDE_INSTALLATION_GREETING_IDES: ReadonlySet<IdeInfo['name']> = new Set([
 
 let ideServer: IDEServer;
 let logger: vscode.OutputChannel;
+let webViewProviders: WebViewProvider[] = []; // Track multiple chat tabs
 
 let log: (message: string) => void = () => {};
 
@@ -108,7 +111,75 @@ export async function activate(context: vscode.ExtensionContext) {
   checkForUpdates(context, log);
 
   const diffContentProvider = new DiffContentProvider();
-  const diffManager = new DiffManager(log, diffContentProvider);
+  const diffManager = new DiffManager(
+    log,
+    diffContentProvider,
+    // Delay when any chat tab has a pending permission drawer
+    () => webViewProviders.some((p) => p.hasPendingPermission()),
+    // Suppress diffs when active mode is auto or yolo in any chat tab
+    () => {
+      const providers = webViewProviders.filter(
+        (p) => typeof p.shouldSuppressDiff === 'function',
+      );
+      if (providers.length === 0) {
+        return false;
+      }
+      return providers.every((p) => p.shouldSuppressDiff());
+    },
+  );
+
+  // Helper function to create a new WebView provider instance
+  const createWebViewProvider = (): WebViewProvider => {
+    const provider = new WebViewProvider(context, context.extensionUri);
+    webViewProviders.push(provider);
+    return provider;
+  };
+
+  // Register WebView panel serializer for persistence across reloads
+  context.subscriptions.push(
+    vscode.window.registerWebviewPanelSerializer('qwenCode.chat', {
+      async deserializeWebviewPanel(
+        webviewPanel: vscode.WebviewPanel,
+        state: unknown,
+      ) {
+        console.log(
+          '[Extension] Deserializing WebView panel with state:',
+          state,
+        );
+
+        // Create a new provider for the restored panel
+        const provider = createWebViewProvider();
+        console.log('[Extension] Provider created for deserialization');
+
+        // Restore state if available BEFORE restoring the panel
+        if (state && typeof state === 'object') {
+          console.log('[Extension] Restoring state:', state);
+          provider.restoreState(
+            state as {
+              conversationId: string | null;
+              agentInitialized: boolean;
+            },
+          );
+        } else {
+          console.log('[Extension] No state to restore or invalid state');
+        }
+
+        await provider.restorePanel(webviewPanel);
+        console.log('[Extension] Panel restore completed');
+
+        log('WebView panel restored from serialization');
+      },
+    }),
+  );
+
+  // Register newly added commands via commands module
+  registerNewCommands(
+    context,
+    log,
+    diffManager,
+    () => webViewProviders,
+    createWebViewProvider,
+  );
 
   context.subscriptions.push(
     vscode.workspace.onDidCloseTextDocument((doc) => {
@@ -120,17 +191,53 @@ export async function activate(context: vscode.ExtensionContext) {
       DIFF_SCHEME,
       diffContentProvider,
     ),
-    vscode.commands.registerCommand('qwen.diff.accept', (uri?: vscode.Uri) => {
+    (vscode.commands.registerCommand('qwen.diff.accept', (uri?: vscode.Uri) => {
       const docUri = uri ?? vscode.window.activeTextEditor?.document.uri;
       if (docUri && docUri.scheme === DIFF_SCHEME) {
         diffManager.acceptDiff(docUri);
       }
+      // If WebView is requesting permission, actively select an allow option (prefer once)
+      try {
+        for (const provider of webViewProviders) {
+          if (provider?.hasPendingPermission()) {
+            provider.respondToPendingPermission('allow');
+          }
+        }
+      } catch (err) {
+        console.warn('[Extension] Auto-allow on diff.accept failed:', err);
+      }
+      console.log('[Extension] Diff accepted');
     }),
     vscode.commands.registerCommand('qwen.diff.cancel', (uri?: vscode.Uri) => {
       const docUri = uri ?? vscode.window.activeTextEditor?.document.uri;
       if (docUri && docUri.scheme === DIFF_SCHEME) {
         diffManager.cancelDiff(docUri);
       }
+      // If WebView is requesting permission, actively select reject/cancel
+      try {
+        for (const provider of webViewProviders) {
+          if (provider?.hasPendingPermission()) {
+            provider.respondToPendingPermission('cancel');
+          }
+        }
+      } catch (err) {
+        console.warn('[Extension] Auto-reject on diff.cancel failed:', err);
+      }
+      console.log('[Extension] Diff cancelled');
+    })),
+    vscode.commands.registerCommand('qwen.diff.closeAll', async () => {
+      try {
+        await diffManager.closeAll();
+      } catch (err) {
+        console.warn('[Extension] qwen.diff.closeAll failed:', err);
+      }
+    }),
+    vscode.commands.registerCommand('qwen.diff.suppressBriefly', async () => {
+      try {
+        diffManager.suppressFor(1200);
+      } catch (err) {
+        console.warn('[Extension] qwen.diff.suppressBriefly failed:', err);
+      }
     }),
   );
 
@@ -160,34 +267,42 @@ export async function activate(context: vscode.ExtensionContext) {
     vscode.workspace.onDidGrantWorkspaceTrust(() => {
       ideServer.syncEnvVars();
     }),
-    vscode.commands.registerCommand('qwen-code.runQwenCode', async () => {
-      const workspaceFolders = vscode.workspace.workspaceFolders;
-      if (!workspaceFolders || workspaceFolders.length === 0) {
-        vscode.window.showInformationMessage(
-          'No folder open. Please open a folder to run Qwen Code.',
-        );
-        return;
-      }
+    vscode.commands.registerCommand(
+      'qwen-code.runQwenCode',
+      async (
+        location?:
+          | vscode.TerminalLocation
+          | vscode.TerminalEditorLocationOptions,
+      ) => {
+        const workspaceFolders = vscode.workspace.workspaceFolders;
+        if (!workspaceFolders || workspaceFolders.length === 0) {
+          vscode.window.showInformationMessage(
+            'No folder open. Please open a folder to run Qwen Code.',
+          );
+          return;
+        }
 
-      let selectedFolder: vscode.WorkspaceFolder | undefined;
-      if (workspaceFolders.length === 1) {
-        selectedFolder = workspaceFolders[0];
-      } else {
-        selectedFolder = await vscode.window.showWorkspaceFolderPick({
-          placeHolder: 'Select a folder to run Qwen Code in',
-        });
-      }
+        let selectedFolder: vscode.WorkspaceFolder | undefined;
+        if (workspaceFolders.length === 1) {
+          selectedFolder = workspaceFolders[0];
+        } else {
+          selectedFolder = await vscode.window.showWorkspaceFolderPick({
+            placeHolder: 'Select a folder to run Qwen Code in',
+          });
+        }
 
-      if (selectedFolder) {
-        const qwenCmd = 'qwen';
-        const terminal = vscode.window.createTerminal({
-          name: `Qwen Code (${selectedFolder.name})`,
-          cwd: selectedFolder.uri.fsPath,
-        });
-        terminal.show();
-        terminal.sendText(qwenCmd);
-      }
-    }),
+        if (selectedFolder) {
+          const qwenCmd = 'qwen';
+          const terminal = vscode.window.createTerminal({
+            name: `Qwen Code (${selectedFolder.name})`,
+            cwd: selectedFolder.uri.fsPath,
+            location,
+          });
+          terminal.show();
+          terminal.sendText(qwenCmd);
+        }
+      },
+    ),
     vscode.commands.registerCommand('qwen-code.showNotices', async () => {
       const noticePath = vscode.Uri.joinPath(
         context.extensionUri,
@@ -204,6 +319,11 @@ export async function deactivate(): Promise<void> {
     if (ideServer) {
       await ideServer.stop();
     }
+    // Dispose all WebView providers
+    webViewProviders.forEach((provider) => {
+      provider.dispose();
+    });
+    webViewProviders = [];
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log(`Failed to stop IDE server during deactivation: ${message}`);

packages/vscode-ide-companion/src/ide-server.ts

@@ -437,6 +437,7 @@ const createMcpServer = (diffManager: DiffManager) => {
       inputSchema: OpenDiffRequestSchema.shape,
     },
     async ({ filePath, newContent }: z.infer<typeof OpenDiffRequestSchema>) => {
+      // Minimal call site: only pass newContent; DiffManager reads old content itself
       await diffManager.showDiff(filePath, newContent);
       return { content: [] };
     },

packages/vscode-ide-companion/src/open-files-manager.test.ts

@@ -414,7 +414,7 @@ describe('OpenFilesManager', () => {
     await vi.advanceTimersByTimeAsync(100);
 
     file1 = manager.state.workspaceState!.openFiles!.find(
-      (f) => f.path === '/test/file1.txt',
+      (f: { path: string }) => f.path === '/test/file1.txt',
     )!;
     const file2 = manager.state.workspaceState!.openFiles![0];
 

packages/vscode-ide-companion/src/services/acpConnection.ts

@@ -0,0 +1,426 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { JSONRPC_VERSION } from '../types/acpTypes.js';
+import type {
+  AcpMessage,
+  AcpPermissionRequest,
+  AcpResponse,
+  AcpSessionUpdate,
+  ApprovalModeValue,
+} from '../types/acpTypes.js';
+import type { ChildProcess, SpawnOptions } from 'child_process';
+import { spawn } from 'child_process';
+import type {
+  PendingRequest,
+  AcpConnectionCallbacks,
+} from '../types/connectionTypes.js';
+import { AcpMessageHandler } from './acpMessageHandler.js';
+import { AcpSessionManager } from './acpSessionManager.js';
+import { determineNodePathForCli } from '../cli/cliPathDetector.js';
+
+/**
+ * ACP Connection Handler for VSCode Extension
+ *
+ * This class implements the client side of the ACP (Agent Communication Protocol).
+ */
+export class AcpConnection {
+  private child: ChildProcess | null = null;
+  private pendingRequests = new Map<number, PendingRequest<unknown>>();
+  private nextRequestId = { value: 0 };
+  // Remember the working dir provided at connect() so later ACP calls
+  // that require cwd (e.g. session/list) can include it.
+  private workingDir: string = process.cwd();
+
+  private messageHandler: AcpMessageHandler;
+  private sessionManager: AcpSessionManager;
+
+  onSessionUpdate: (data: AcpSessionUpdate) => void = () => {};
+  onPermissionRequest: (data: AcpPermissionRequest) => Promise<{
+    optionId: string;
+  }> = () => Promise.resolve({ optionId: 'allow' });
+  onEndTurn: () => void = () => {};
+  // Called after successful initialize() with the initialize result
+  onInitialized: (init: unknown) => void = () => {};
+
+  constructor() {
+    this.messageHandler = new AcpMessageHandler();
+    this.sessionManager = new AcpSessionManager();
+  }
+
+  /**
+   * Connect to Qwen ACP
+   *
+   * @param cliPath - CLI path
+   * @param workingDir - Working directory
+   * @param extraArgs - Extra command line arguments
+   */
+  async connect(
+    cliPath: string,
+    workingDir: string = process.cwd(),
+    extraArgs: string[] = [],
+  ): Promise<void> {
+    if (this.child) {
+      this.disconnect();
+    }
+
+    this.workingDir = workingDir;
+
+    const isWindows = process.platform === 'win32';
+    const env = { ...process.env };
+
+    // If proxy is configured in extraArgs, also set it as environment variable
+    // This ensures token refresh requests also use the proxy
+    const proxyArg = extraArgs.find(
+      (arg, i) => arg === '--proxy' && i + 1 < extraArgs.length,
+    );
+    if (proxyArg) {
+      const proxyIndex = extraArgs.indexOf('--proxy');
+      const proxyUrl = extraArgs[proxyIndex + 1];
+      console.log('[ACP] Setting proxy environment variables:', proxyUrl);
+
+      env['HTTP_PROXY'] = proxyUrl;
+      env['HTTPS_PROXY'] = proxyUrl;
+      env['http_proxy'] = proxyUrl;
+      env['https_proxy'] = proxyUrl;
+    }
+
+    let spawnCommand: string;
+    let spawnArgs: string[];
+
+    if (cliPath.startsWith('npx ')) {
+      const parts = cliPath.split(' ');
+      spawnCommand = isWindows ? 'npx.cmd' : 'npx';
+      spawnArgs = [...parts.slice(1), '--experimental-acp', ...extraArgs];
+    } else {
+      // For qwen CLI, ensure we use the correct Node.js version
+      // Handle various Node.js version managers (nvm, n, manual installations)
+      if (cliPath.includes('/qwen') && !isWindows) {
+        // Try to determine the correct node executable for this qwen installation
+        const nodePathResult = determineNodePathForCli(cliPath);
+        if (nodePathResult.path) {
+          spawnCommand = nodePathResult.path;
+          spawnArgs = [cliPath, '--experimental-acp', ...extraArgs];
+        } else {
+          // Fallback to direct execution
+          spawnCommand = cliPath;
+          spawnArgs = ['--experimental-acp', ...extraArgs];
+
+          // Log any error for debugging
+          if (nodePathResult.error) {
+            console.warn(
+              `[ACP] Node.js path detection warning: ${nodePathResult.error}`,
+            );
+          }
+        }
+      } else {
+        spawnCommand = cliPath;
+        spawnArgs = ['--experimental-acp', ...extraArgs];
+      }
+    }
+
+    console.log('[ACP] Spawning command:', spawnCommand, spawnArgs.join(' '));
+
+    const options: SpawnOptions = {
+      cwd: workingDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env,
+      shell: isWindows,
+    };
+
+    this.child = spawn(spawnCommand, spawnArgs, options);
+    await this.setupChildProcessHandlers();
+  }
+
+  /**
+   * Set up child process handlers
+   */
+  private async setupChildProcessHandlers(): Promise<void> {
+    let spawnError: Error | null = null;
+
+    this.child!.stderr?.on('data', (data) => {
+      const message = data.toString();
+      if (
+        message.toLowerCase().includes('error') &&
+        !message.includes('Loaded cached')
+      ) {
+        console.error(`[ACP qwen]:`, message);
+      } else {
+        console.log(`[ACP qwen]:`, message);
+      }
+    });
+
+    this.child!.on('error', (error) => {
+      spawnError = error;
+    });
+
+    this.child!.on('exit', (code, signal) => {
+      console.error(
+        `[ACP qwen] Process exited with code: ${code}, signal: ${signal}`,
+      );
+    });
+
+    // Wait for process to start
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    if (spawnError) {
+      throw spawnError;
+    }
+
+    if (!this.child || this.child.killed) {
+      throw new Error(`Qwen ACP process failed to start`);
+    }
+
+    // Handle messages from ACP server
+    let buffer = '';
+    this.child.stdout?.on('data', (data) => {
+      buffer += data.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line) as AcpMessage;
+            console.log(
+              '[ACP] <<< Received message:',
+              JSON.stringify(message).substring(0, 500 * 3),
+            );
+            this.handleMessage(message);
+          } catch (_error) {
+            // Ignore non-JSON lines
+            console.log(
+              '[ACP] <<< Non-JSON line (ignored):',
+              line.substring(0, 200),
+            );
+          }
+        }
+      }
+    });
+
+    // Initialize protocol
+    const res = await this.sessionManager.initialize(
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+
+    console.log('[ACP] Initialization response:', res);
+    try {
+      this.onInitialized(res);
+    } catch (err) {
+      console.warn('[ACP] onInitialized callback error:', err);
+    }
+  }
+
+  /**
+   * Handle received messages
+   *
+   * @param message - ACP message
+   */
+  private handleMessage(message: AcpMessage): void {
+    const callbacks: AcpConnectionCallbacks = {
+      onSessionUpdate: this.onSessionUpdate,
+      onPermissionRequest: this.onPermissionRequest,
+      onEndTurn: this.onEndTurn,
+    };
+
+    // Handle message
+    if ('method' in message) {
+      // Request or notification
+      this.messageHandler
+        .handleIncomingRequest(message, callbacks)
+        .then((result) => {
+          if ('id' in message && typeof message.id === 'number') {
+            this.messageHandler.sendResponseMessage(this.child, {
+              jsonrpc: JSONRPC_VERSION,
+              id: message.id,
+              result,
+            });
+          }
+        })
+        .catch((error) => {
+          if ('id' in message && typeof message.id === 'number') {
+            this.messageHandler.sendResponseMessage(this.child, {
+              jsonrpc: JSONRPC_VERSION,
+              id: message.id,
+              error: {
+                code: -32603,
+                message: error instanceof Error ? error.message : String(error),
+              },
+            });
+          }
+        });
+    } else {
+      // Response
+      this.messageHandler.handleMessage(
+        message,
+        this.pendingRequests,
+        callbacks,
+      );
+    }
+  }
+
+  /**
+   * Authenticate
+   *
+   * @param methodId - Authentication method ID
+   * @returns Authentication response
+   */
+  async authenticate(methodId?: string): Promise<AcpResponse> {
+    return this.sessionManager.authenticate(
+      methodId,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+  }
+
+  /**
+   * Create new session
+   *
+   * @param cwd - Working directory
+   * @returns New session response
+   */
+  async newSession(cwd: string = process.cwd()): Promise<AcpResponse> {
+    return this.sessionManager.newSession(
+      cwd,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+  }
+
+  /**
+   * Send prompt message
+   *
+   * @param prompt - Prompt content
+   * @returns Response
+   */
+  async sendPrompt(prompt: string): Promise<AcpResponse> {
+    return this.sessionManager.sendPrompt(
+      prompt,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+  }
+
+  /**
+   * Load existing session
+   *
+   * @param sessionId - Session ID
+   * @returns Load response
+   */
+  async loadSession(
+    sessionId: string,
+    cwdOverride?: string,
+  ): Promise<AcpResponse> {
+    return this.sessionManager.loadSession(
+      sessionId,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+      cwdOverride || this.workingDir,
+    );
+  }
+
+  /**
+   * Get session list
+   *
+   * @returns Session list response
+   */
+  async listSessions(options?: {
+    cursor?: number;
+    size?: number;
+  }): Promise<AcpResponse> {
+    return this.sessionManager.listSessions(
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+      this.workingDir,
+      options,
+    );
+  }
+
+  /**
+   * Switch to specified session
+   *
+   * @param sessionId - Session ID
+   * @returns Switch response
+   */
+  async switchSession(sessionId: string): Promise<AcpResponse> {
+    return this.sessionManager.switchSession(sessionId, this.nextRequestId);
+  }
+
+  /**
+   * Cancel current session prompt generation
+   */
+  async cancelSession(): Promise<void> {
+    await this.sessionManager.cancelSession(this.child);
+  }
+
+  /**
+   * Save current session
+   *
+   * @param tag - Save tag
+   * @returns Save response
+   */
+  async saveSession(tag: string): Promise<AcpResponse> {
+    return this.sessionManager.saveSession(
+      tag,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+  }
+
+  /**
+   * Set approval mode
+   */
+  async setMode(modeId: ApprovalModeValue): Promise<AcpResponse> {
+    return this.sessionManager.setMode(
+      modeId,
+      this.child,
+      this.pendingRequests,
+      this.nextRequestId,
+    );
+  }
+
+  /**
+   * Disconnect
+   */
+  disconnect(): void {
+    if (this.child) {
+      this.child.kill();
+      this.child = null;
+    }
+
+    this.pendingRequests.clear();
+    this.sessionManager.reset();
+  }
+
+  /**
+   * Check if connected
+   */
+  get isConnected(): boolean {
+    return this.child !== null && !this.child.killed;
+  }
+
+  /**
+   * Check if there is an active session
+   */
+  get hasActiveSession(): boolean {
+    return this.sessionManager.getCurrentSessionId() !== null;
+  }
+
+  /**
+   * Get current session ID
+   */
+  get currentSessionId(): string | null {
+    return this.sessionManager.getCurrentSessionId();
+  }
+}

packages/vscode-ide-companion/src/services/acpFileHandler.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * ACP File Operation Handler
+ *
+ * Responsible for handling file read and write operations in the ACP protocol
+ */
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+/**
+ * ACP File Operation Handler Class
+ * Provides file read and write functionality according to ACP protocol specifications
+ */
+export class AcpFileHandler {
+  /**
+   * Handle read text file request
+   *
+   * @param params - File read parameters
+   * @param params.path - File path
+   * @param params.sessionId - Session ID
+   * @param params.line - Starting line number (optional)
+   * @param params.limit - Read line limit (optional)
+   * @returns File content
+   * @throws Error when file reading fails
+   */
+  async handleReadTextFile(params: {
+    path: string;
+    sessionId: string;
+    line: number | null;
+    limit: number | null;
+  }): Promise<{ content: string }> {
+    console.log(`[ACP] fs/read_text_file request received for: ${params.path}`);
+    console.log(`[ACP] Parameters:`, {
+      line: params.line,
+      limit: params.limit,
+      sessionId: params.sessionId,
+    });
+
+    try {
+      const content = await fs.readFile(params.path, 'utf-8');
+      console.log(
+        `[ACP] Successfully read file: ${params.path} (${content.length} bytes)`,
+      );
+
+      // Handle line offset and limit
+      if (params.line !== null || params.limit !== null) {
+        const lines = content.split('\n');
+        const startLine = params.line || 0;
+        const endLine = params.limit ? startLine + params.limit : lines.length;
+        const selectedLines = lines.slice(startLine, endLine);
+        const result = { content: selectedLines.join('\n') };
+        console.log(`[ACP] Returning ${selectedLines.length} lines`);
+        return result;
+      }
+
+      const result = { content };
+      console.log(`[ACP] Returning full file content`);
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[ACP] Failed to read file ${params.path}:`, errorMsg);
+
+      throw new Error(`Failed to read file '${params.path}': ${errorMsg}`);
+    }
+  }
+
+  /**
+   * Handle write text file request
+   *
+   * @param params - File write parameters
+   * @param params.path - File path
+   * @param params.content - File content
+   * @param params.sessionId - Session ID
+   * @returns null indicates success
+   * @throws Error when file writing fails
+   */
+  async handleWriteTextFile(params: {
+    path: string;
+    content: string;
+    sessionId: string;
+  }): Promise<null> {
+    console.log(
+      `[ACP] fs/write_text_file request received for: ${params.path}`,
+    );
+    console.log(`[ACP] Content size: ${params.content.length} bytes`);
+
+    try {
+      // Ensure directory exists
+      const dirName = path.dirname(params.path);
+      console.log(`[ACP] Ensuring directory exists: ${dirName}`);
+      await fs.mkdir(dirName, { recursive: true });
+
+      // Write file
+      await fs.writeFile(params.path, params.content, 'utf-8');
+
+      console.log(`[ACP] Successfully wrote file: ${params.path}`);
+      return null;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[ACP] Failed to write file ${params.path}:`, errorMsg);
+
+      throw new Error(`Failed to write file '${params.path}': ${errorMsg}`);
+    }
+  }
+}

packages/vscode-ide-companion/src/services/acpMessageHandler.ts

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * ACP Message Handler
+ *
+ * Responsible for receiving, parsing, and distributing messages in the ACP protocol
+ */
+
+import type {
+  AcpMessage,
+  AcpRequest,
+  AcpNotification,
+  AcpResponse,
+  AcpSessionUpdate,
+  AcpPermissionRequest,
+} from '../types/acpTypes.js';
+import { CLIENT_METHODS } from '../constants/acpSchema.js';
+import type {
+  PendingRequest,
+  AcpConnectionCallbacks,
+} from '../types/connectionTypes.js';
+import { AcpFileHandler } from '../services/acpFileHandler.js';
+import type { ChildProcess } from 'child_process';
+
+/**
+ * ACP Message Handler Class
+ * Responsible for receiving, parsing, and processing messages
+ */
+export class AcpMessageHandler {
+  private fileHandler: AcpFileHandler;
+
+  constructor() {
+    this.fileHandler = new AcpFileHandler();
+  }
+
+  /**
+   * Send response message to child process
+   *
+   * @param child - Child process instance
+   * @param response - Response message
+   */
+  sendResponseMessage(child: ChildProcess | null, response: AcpResponse): void {
+    if (child?.stdin) {
+      const jsonString = JSON.stringify(response);
+      const lineEnding = process.platform === 'win32' ? '\r\n' : '\n';
+      child.stdin.write(jsonString + lineEnding);
+    }
+  }
+
+  /**
+   * Handle received messages
+   *
+   * @param message - ACP message
+   * @param pendingRequests - Pending requests map
+   * @param callbacks - Callback functions collection
+   */
+  handleMessage(
+    message: AcpMessage,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    callbacks: AcpConnectionCallbacks,
+  ): void {
+    try {
+      if ('method' in message) {
+        // Request or notification
+        this.handleIncomingRequest(message, callbacks).catch(() => {});
+      } else if (
+        'id' in message &&
+        typeof message.id === 'number' &&
+        pendingRequests.has(message.id)
+      ) {
+        // Response
+        this.handleResponse(message, pendingRequests, callbacks);
+      }
+    } catch (error) {
+      console.error('[ACP] Error handling message:', error);
+    }
+  }
+
+  /**
+   * Handle response message
+   *
+   * @param message - Response message
+   * @param pendingRequests - Pending requests map
+   * @param callbacks - Callback functions collection
+   */
+  private handleResponse(
+    message: AcpMessage,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    callbacks: AcpConnectionCallbacks,
+  ): void {
+    if (!('id' in message) || typeof message.id !== 'number') {
+      return;
+    }
+
+    const pendingRequest = pendingRequests.get(message.id);
+    if (!pendingRequest) {
+      return;
+    }
+
+    const { resolve, reject, method } = pendingRequest;
+    pendingRequests.delete(message.id);
+
+    if ('result' in message) {
+      console.log(
+        `[ACP] Response for ${method}:`,
+        // JSON.stringify(message.result).substring(0, 200),
+        message.result,
+      );
+      if (
+        message.result &&
+        typeof message.result === 'object' &&
+        'stopReason' in message.result &&
+        message.result.stopReason === 'end_turn'
+      ) {
+        callbacks.onEndTurn();
+      }
+      resolve(message.result);
+    } else if ('error' in message) {
+      const errorCode = message.error?.code || 'unknown';
+      const errorMsg = message.error?.message || 'Unknown ACP error';
+      const errorData = message.error?.data
+        ? JSON.stringify(message.error.data)
+        : '';
+      console.error(`[ACP] Error response for ${method}:`, {
+        code: errorCode,
+        message: errorMsg,
+        data: errorData,
+      });
+      reject(
+        new Error(
+          `${errorMsg} (code: ${errorCode})${errorData ? '\nData: ' + errorData : ''}`,
+        ),
+      );
+    }
+  }
+
+  /**
+   * Handle incoming requests
+   *
+   * @param message - Request or notification message
+   * @param callbacks - Callback functions collection
+   * @returns Request processing result
+   */
+  async handleIncomingRequest(
+    message: AcpRequest | AcpNotification,
+    callbacks: AcpConnectionCallbacks,
+  ): Promise<unknown> {
+    const { method, params } = message;
+
+    let result = null;
+
+    switch (method) {
+      case CLIENT_METHODS.session_update:
+        console.log(
+          '[ACP] >>> Processing session_update:',
+          JSON.stringify(params).substring(0, 300),
+        );
+        callbacks.onSessionUpdate(params as AcpSessionUpdate);
+        break;
+      case CLIENT_METHODS.session_request_permission:
+        result = await this.handlePermissionRequest(
+          params as AcpPermissionRequest,
+          callbacks,
+        );
+        break;
+      case CLIENT_METHODS.fs_read_text_file:
+        result = await this.fileHandler.handleReadTextFile(
+          params as {
+            path: string;
+            sessionId: string;
+            line: number | null;
+            limit: number | null;
+          },
+        );
+        break;
+      case CLIENT_METHODS.fs_write_text_file:
+        result = await this.fileHandler.handleWriteTextFile(
+          params as { path: string; content: string; sessionId: string },
+        );
+        break;
+      default:
+        console.warn(`[ACP] Unhandled method: ${method}`);
+        break;
+    }
+
+    return result;
+  }
+
+  /**
+   * Handle permission requests
+   *
+   * @param params - Permission request parameters
+   * @param callbacks - Callback functions collection
+   * @returns Permission request result
+   */
+  private async handlePermissionRequest(
+    params: AcpPermissionRequest,
+    callbacks: AcpConnectionCallbacks,
+  ): Promise<{
+    outcome: { outcome: string; optionId: string };
+  }> {
+    try {
+      const response = await callbacks.onPermissionRequest(params);
+      const optionId = response?.optionId;
+      console.log('[ACP] Permission request:', optionId);
+      // Handle cancel, deny, or allow
+      let outcome: string;
+      if (optionId && (optionId.includes('reject') || optionId === 'cancel')) {
+        outcome = 'cancelled';
+      } else {
+        outcome = 'selected';
+      }
+      console.log('[ACP] Permission outcome:', outcome);
+
+      return {
+        outcome: {
+          outcome,
+          // optionId: optionId === 'cancel' ? 'cancel' : optionId,
+          optionId,
+        },
+      };
+    } catch (_error) {
+      return {
+        outcome: {
+          outcome: 'rejected',
+          optionId: 'reject_once',
+        },
+      };
+    }
+  }
+}

packages/vscode-ide-companion/src/services/acpSessionManager.ts

@@ -0,0 +1,474 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * ACP Session Manager
+ *
+ * Responsible for managing ACP protocol session operations, including initialization, authentication, session creation, and switching
+ */
+import { JSONRPC_VERSION } from '../types/acpTypes.js';
+import type {
+  AcpRequest,
+  AcpNotification,
+  AcpResponse,
+  ApprovalModeValue,
+} from '../types/acpTypes.js';
+import { AGENT_METHODS } from '../constants/acpSchema.js';
+import type { PendingRequest } from '../types/connectionTypes.js';
+import type { ChildProcess } from 'child_process';
+
+/**
+ * ACP Session Manager Class
+ * Provides session initialization, authentication, creation, loading, and switching functionality
+ */
+export class AcpSessionManager {
+  private sessionId: string | null = null;
+  private isInitialized = false;
+
+  /**
+   * Send request to ACP server
+   *
+   * @param method - Request method name
+   * @param params - Request parameters
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Request response
+   */
+  private sendRequest<T = unknown>(
+    method: string,
+    params: Record<string, unknown> | undefined,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<T> {
+    const id = nextRequestId.value++;
+    const message: AcpRequest = {
+      jsonrpc: JSONRPC_VERSION,
+      id,
+      method,
+      ...(params && { params }),
+    };
+
+    return new Promise((resolve, reject) => {
+      const timeoutDuration =
+        method === AGENT_METHODS.session_prompt ? 120000 : 60000;
+
+      const timeoutId = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out`));
+      }, timeoutDuration);
+
+      const pendingRequest: PendingRequest<T> = {
+        resolve: (value: T) => {
+          clearTimeout(timeoutId);
+          resolve(value);
+        },
+        reject: (error: Error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        },
+        timeoutId,
+        method,
+      };
+
+      pendingRequests.set(id, pendingRequest as PendingRequest<unknown>);
+      this.sendMessage(message, child);
+    });
+  }
+
+  /**
+   * Send message to child process
+   *
+   * @param message - Request or notification message
+   * @param child - Child process instance
+   */
+  private sendMessage(
+    message: AcpRequest | AcpNotification,
+    child: ChildProcess | null,
+  ): void {
+    if (child?.stdin) {
+      const jsonString = JSON.stringify(message);
+      const lineEnding = process.platform === 'win32' ? '\r\n' : '\n';
+      child.stdin.write(jsonString + lineEnding);
+    }
+  }
+
+  /**
+   * Initialize ACP protocol connection
+   *
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Initialization response
+   */
+  async initialize(
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    const initializeParams = {
+      protocolVersion: 1,
+      clientCapabilities: {
+        fs: {
+          readTextFile: true,
+          writeTextFile: true,
+        },
+      },
+    };
+
+    console.log('[ACP] Sending initialize request...');
+    const response = await this.sendRequest<AcpResponse>(
+      AGENT_METHODS.initialize,
+      initializeParams,
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+    this.isInitialized = true;
+
+    console.log('[ACP] Initialize successful');
+    return response;
+  }
+
+  /**
+   * Perform authentication
+   *
+   * @param methodId - Authentication method ID
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Authentication response
+   */
+  async authenticate(
+    methodId: string | undefined,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    const authMethodId = methodId || 'default';
+    console.log(
+      '[ACP] Sending authenticate request with methodId:',
+      authMethodId,
+    );
+    const response = await this.sendRequest<AcpResponse>(
+      AGENT_METHODS.authenticate,
+      {
+        methodId: authMethodId,
+      },
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+    console.log('[ACP] Authenticate successful');
+    return response;
+  }
+
+  /**
+   * Create new session
+   *
+   * @param cwd - Working directory
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns New session response
+   */
+  async newSession(
+    cwd: string,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    console.log('[ACP] Sending session/new request with cwd:', cwd);
+    const response = await this.sendRequest<
+      AcpResponse & { sessionId?: string }
+    >(
+      AGENT_METHODS.session_new,
+      {
+        cwd,
+        mcpServers: [],
+      },
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+
+    this.sessionId = (response && response.sessionId) || null;
+    console.log('[ACP] Session created with ID:', this.sessionId);
+    return response;
+  }
+
+  /**
+   * Send prompt message
+   *
+   * @param prompt - Prompt content
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Response
+   * @throws Error when there is no active session
+   */
+  async sendPrompt(
+    prompt: string,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    if (!this.sessionId) {
+      throw new Error('No active ACP session');
+    }
+
+    return await this.sendRequest(
+      AGENT_METHODS.session_prompt,
+      {
+        sessionId: this.sessionId,
+        prompt: [{ type: 'text', text: prompt }],
+      },
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+  }
+
+  /**
+   * Load existing session
+   *
+   * @param sessionId - Session ID
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Load response
+   */
+  async loadSession(
+    sessionId: string,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+    cwd: string = process.cwd(),
+  ): Promise<AcpResponse> {
+    console.log('[ACP] Sending session/load request for session:', sessionId);
+    console.log('[ACP] Request parameters:', {
+      sessionId,
+      cwd,
+      mcpServers: [],
+    });
+
+    try {
+      const response = await this.sendRequest<AcpResponse>(
+        AGENT_METHODS.session_load,
+        {
+          sessionId,
+          cwd,
+          mcpServers: [],
+        },
+        child,
+        pendingRequests,
+        nextRequestId,
+      );
+
+      console.log(
+        '[ACP] Session load response:',
+        JSON.stringify(response).substring(0, 500),
+      );
+
+      // Check if response contains an error
+      if (response && response.error) {
+        console.error('[ACP] Session load returned error:', response.error);
+      } else {
+        console.log('[ACP] Session load succeeded');
+        // session/load returns null on success per schema; update local sessionId
+        // so subsequent prompts use the loaded session.
+        this.sessionId = sessionId;
+      }
+
+      return response;
+    } catch (error) {
+      console.error(
+        '[ACP] Session load request failed with exception:',
+        error instanceof Error ? error.message : String(error),
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Get session list
+   *
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Session list response
+   */
+  async listSessions(
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+    cwd: string = process.cwd(),
+    options?: { cursor?: number; size?: number },
+  ): Promise<AcpResponse> {
+    console.log('[ACP] Requesting session list...');
+    try {
+      // session/list requires cwd in params per ACP schema
+      const params: Record<string, unknown> = { cwd };
+      if (options?.cursor !== undefined) {
+        params.cursor = options.cursor;
+      }
+      if (options?.size !== undefined) {
+        params.size = options.size;
+      }
+
+      const response = await this.sendRequest<AcpResponse>(
+        AGENT_METHODS.session_list,
+        params,
+        child,
+        pendingRequests,
+        nextRequestId,
+      );
+      console.log(
+        '[ACP] Session list response:',
+        JSON.stringify(response).substring(0, 200),
+      );
+      return response;
+    } catch (error) {
+      console.error('[ACP] Failed to get session list:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Set approval mode for current session (ACP session/set_mode)
+   *
+   * @param modeId - Approval mode value
+   */
+  async setMode(
+    modeId: ApprovalModeValue,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    if (!this.sessionId) {
+      throw new Error('No active ACP session');
+    }
+    console.log('[ACP] Sending session/set_mode:', modeId);
+    const res = await this.sendRequest<AcpResponse>(
+      AGENT_METHODS.session_set_mode,
+      { sessionId: this.sessionId, modeId },
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+    console.log('[ACP] set_mode response:', res);
+    return res;
+  }
+
+  /**
+   * Switch to specified session
+   *
+   * @param sessionId - Session ID
+   * @param nextRequestId - Request ID counter
+   * @returns Switch response
+   */
+  async switchSession(
+    sessionId: string,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    console.log('[ACP] Switching to session:', sessionId);
+    this.sessionId = sessionId;
+
+    const mockResponse: AcpResponse = {
+      jsonrpc: JSONRPC_VERSION,
+      id: nextRequestId.value++,
+      result: { sessionId },
+    };
+    console.log(
+      '[ACP] Session ID updated locally (switch not supported by CLI)',
+    );
+    return mockResponse;
+  }
+
+  /**
+   * Cancel prompt generation for current session
+   *
+   * @param child - Child process instance
+   */
+  async cancelSession(child: ChildProcess | null): Promise<void> {
+    if (!this.sessionId) {
+      console.warn('[ACP] No active session to cancel');
+      return;
+    }
+
+    console.log('[ACP] Cancelling session:', this.sessionId);
+
+    const cancelParams = {
+      sessionId: this.sessionId,
+    };
+
+    const message: AcpNotification = {
+      jsonrpc: JSONRPC_VERSION,
+      method: AGENT_METHODS.session_cancel,
+      params: cancelParams,
+    };
+
+    this.sendMessage(message, child);
+    console.log('[ACP] Cancel notification sent');
+  }
+
+  /**
+   * Save current session
+   *
+   * @param tag - Save tag
+   * @param child - Child process instance
+   * @param pendingRequests - Pending requests map
+   * @param nextRequestId - Request ID counter
+   * @returns Save response
+   */
+  async saveSession(
+    tag: string,
+    child: ChildProcess | null,
+    pendingRequests: Map<number, PendingRequest<unknown>>,
+    nextRequestId: { value: number },
+  ): Promise<AcpResponse> {
+    if (!this.sessionId) {
+      throw new Error('No active ACP session');
+    }
+
+    console.log('[ACP] Saving session with tag:', tag);
+    const response = await this.sendRequest<AcpResponse>(
+      AGENT_METHODS.session_save,
+      {
+        sessionId: this.sessionId,
+        tag,
+      },
+      child,
+      pendingRequests,
+      nextRequestId,
+    );
+    console.log('[ACP] Session save response:', response);
+    return response;
+  }
+
+  /**
+   * Reset session manager state
+   */
+  reset(): void {
+    this.sessionId = null;
+    this.isInitialized = false;
+  }
+
+  /**
+   * Get current session ID
+   */
+  getCurrentSessionId(): string | null {
+    return this.sessionId;
+  }
+
+  /**
+   * Check if initialized
+   */
+  getIsInitialized(): boolean {
+    return this.isInitialized;
+  }
+}

packages/vscode-ide-companion/src/services/authStateManager.ts

@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as vscode from 'vscode';
+
+interface AuthState {
+  isAuthenticated: boolean;
+  authMethod: string;
+  timestamp: number;
+  workingDir?: string;
+}
+
+/**
+ * Manages authentication state caching to avoid repeated logins
+ */
+export class AuthStateManager {
+  private static instance: AuthStateManager | null = null;
+  private static context: vscode.ExtensionContext | null = null;
+  private static readonly AUTH_STATE_KEY = 'qwen.authState';
+  private static readonly AUTH_CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours
+  private constructor() {}
+
+  /**
+   * Get singleton instance of AuthStateManager
+   */
+  static getInstance(context?: vscode.ExtensionContext): AuthStateManager {
+    if (!AuthStateManager.instance) {
+      AuthStateManager.instance = new AuthStateManager();
+    }
+
+    // If a context is provided, update the static context
+    if (context) {
+      AuthStateManager.context = context;
+    }
+
+    return AuthStateManager.instance;
+  }
+
+  /**
+   * Check if there's a valid cached authentication
+   */
+  async hasValidAuth(workingDir: string, authMethod: string): Promise<boolean> {
+    const state = await this.getAuthState();
+
+    if (!state) {
+      console.log('[AuthStateManager] No cached auth state found');
+      return false;
+    }
+
+    console.log('[AuthStateManager] Found cached auth state:', {
+      workingDir: state.workingDir,
+      authMethod: state.authMethod,
+      timestamp: new Date(state.timestamp).toISOString(),
+      isAuthenticated: state.isAuthenticated,
+    });
+    console.log('[AuthStateManager] Checking against:', {
+      workingDir,
+      authMethod,
+    });
+
+    // Check if auth is still valid (within cache duration)
+    const now = Date.now();
+    const isExpired =
+      now - state.timestamp > AuthStateManager.AUTH_CACHE_DURATION;
+
+    if (isExpired) {
+      console.log('[AuthStateManager] Cached auth expired');
+      console.log(
+        '[AuthStateManager] Cache age:',
+        Math.floor((now - state.timestamp) / 1000 / 60),
+        'minutes',
+      );
+      await this.clearAuthState();
+      return false;
+    }
+
+    // Check if it's for the same working directory and auth method
+    const isSameContext =
+      state.workingDir === workingDir && state.authMethod === authMethod;
+
+    if (!isSameContext) {
+      console.log('[AuthStateManager] Working dir or auth method changed');
+      console.log('[AuthStateManager] Cached workingDir:', state.workingDir);
+      console.log('[AuthStateManager] Current workingDir:', workingDir);
+      console.log('[AuthStateManager] Cached authMethod:', state.authMethod);
+      console.log('[AuthStateManager] Current authMethod:', authMethod);
+      return false;
+    }
+
+    console.log('[AuthStateManager] Valid cached auth found');
+    return state.isAuthenticated;
+  }
+
+  /**
+   * Force check auth state without clearing cache
+   * This is useful for debugging to see what's actually cached
+   */
+  async debugAuthState(): Promise<void> {
+    const state = await this.getAuthState();
+    console.log('[AuthStateManager] DEBUG - Current auth state:', state);
+
+    if (state) {
+      const now = Date.now();
+      const age = Math.floor((now - state.timestamp) / 1000 / 60);
+      const isExpired =
+        now - state.timestamp > AuthStateManager.AUTH_CACHE_DURATION;
+
+      console.log('[AuthStateManager] DEBUG - Auth state age:', age, 'minutes');
+      console.log('[AuthStateManager] DEBUG - Auth state expired:', isExpired);
+      console.log(
+        '[AuthStateManager] DEBUG - Auth state valid:',
+        state.isAuthenticated,
+      );
+    }
+  }
+
+  /**
+   * Save successful authentication state
+   */
+  async saveAuthState(workingDir: string, authMethod: string): Promise<void> {
+    // Ensure we have a valid context
+    if (!AuthStateManager.context) {
+      throw new Error(
+        '[AuthStateManager] No context available for saving auth state',
+      );
+    }
+
+    const state: AuthState = {
+      isAuthenticated: true,
+      authMethod,
+      workingDir,
+      timestamp: Date.now(),
+    };
+
+    console.log('[AuthStateManager] Saving auth state:', {
+      workingDir,
+      authMethod,
+      timestamp: new Date(state.timestamp).toISOString(),
+    });
+
+    await AuthStateManager.context.globalState.update(
+      AuthStateManager.AUTH_STATE_KEY,
+      state,
+    );
+    console.log('[AuthStateManager] Auth state saved');
+
+    // Verify the state was saved correctly
+    const savedState = await this.getAuthState();
+    console.log('[AuthStateManager] Verified saved state:', savedState);
+  }
+
+  /**
+   * Clear authentication state
+   */
+  async clearAuthState(): Promise<void> {
+    // Ensure we have a valid context
+    if (!AuthStateManager.context) {
+      throw new Error(
+        '[AuthStateManager] No context available for clearing auth state',
+      );
+    }
+
+    console.log('[AuthStateManager] Clearing auth state');
+    const currentState = await this.getAuthState();
+    console.log(
+      '[AuthStateManager] Current state before clearing:',
+      currentState,
+    );
+
+    await AuthStateManager.context.globalState.update(
+      AuthStateManager.AUTH_STATE_KEY,
+      undefined,
+    );
+    console.log('[AuthStateManager] Auth state cleared');
+
+    // Verify the state was cleared
+    const newState = await this.getAuthState();
+    console.log('[AuthStateManager] State after clearing:', newState);
+  }
+
+  /**
+   * Get current auth state
+   */
+  private async getAuthState(): Promise<AuthState | undefined> {
+    // Ensure we have a valid context
+    if (!AuthStateManager.context) {
+      console.log(
+        '[AuthStateManager] No context available for getting auth state',
+      );
+      return undefined;
+    }
+
+    const a = AuthStateManager.context.globalState.get<AuthState>(
+      AuthStateManager.AUTH_STATE_KEY,
+    );
+    console.log('[AuthStateManager] Auth state:', a);
+    return a;
+  }
+
+  /**
+   * Get auth state info for debugging
+   */
+  async getAuthInfo(): Promise<string> {
+    const state = await this.getAuthState();
+    if (!state) {
+      return 'No cached auth';
+    }
+
+    const age = Math.floor((Date.now() - state.timestamp) / 1000 / 60);
+    return `Auth cached ${age}m ago, method: ${state.authMethod}`;
+  }
+}

packages/vscode-ide-companion/src/services/conversationStore.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as vscode from 'vscode';
+import type { ChatMessage } from './qwenAgentManager.js';
+
+export interface Conversation {
+  id: string;
+  title: string;
+  messages: ChatMessage[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export class ConversationStore {
+  private context: vscode.ExtensionContext;
+  private currentConversationId: string | null = null;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+  }
+
+  async createConversation(title: string = 'New Chat'): Promise<Conversation> {
+    const conversation: Conversation = {
+      id: `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      title,
+      messages: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+
+    const conversations = await this.getAllConversations();
+    conversations.push(conversation);
+    await this.context.globalState.update('conversations', conversations);
+
+    this.currentConversationId = conversation.id;
+    return conversation;
+  }
+
+  async getAllConversations(): Promise<Conversation[]> {
+    return this.context.globalState.get<Conversation[]>('conversations', []);
+  }
+
+  async getConversation(id: string): Promise<Conversation | null> {
+    const conversations = await this.getAllConversations();
+    return conversations.find((c) => c.id === id) || null;
+  }
+
+  async addMessage(
+    conversationId: string,
+    message: ChatMessage,
+  ): Promise<void> {
+    const conversations = await this.getAllConversations();
+    const conversation = conversations.find((c) => c.id === conversationId);
+
+    if (conversation) {
+      conversation.messages.push(message);
+      conversation.updatedAt = Date.now();
+      await this.context.globalState.update('conversations', conversations);
+    }
+  }
+
+  async deleteConversation(id: string): Promise<void> {
+    const conversations = await this.getAllConversations();
+    const filtered = conversations.filter((c) => c.id !== id);
+    await this.context.globalState.update('conversations', filtered);
+
+    if (this.currentConversationId === id) {
+      this.currentConversationId = null;
+    }
+  }
+
+  getCurrentConversationId(): string | null {
+    return this.currentConversationId;
+  }
+
+  setCurrentConversationId(id: string): void {
+    this.currentConversationId = id;
+  }
+}

packages/vscode-ide-companion/src/services/qwenConnectionHandler.ts

@@ -0,0 +1,260 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Qwen Connection Handler
+ *
+ * Handles Qwen Agent connection establishment, authentication, and session creation
+ */
+
+import * as vscode from 'vscode';
+import type { AcpConnection } from './acpConnection.js';
+import type { QwenSessionReader } from '../services/qwenSessionReader.js';
+import type { AuthStateManager } from '../services/authStateManager.js';
+import {
+  CliVersionManager,
+  MIN_CLI_VERSION_FOR_SESSION_METHODS,
+} from '../cli/cliVersionManager.js';
+import { CliContextManager } from '../cli/cliContextManager.js';
+import { authMethod } from '../types/acpTypes.js';
+
+/**
+ * Qwen Connection Handler class
+ * Handles connection, authentication, and session initialization
+ */
+export class QwenConnectionHandler {
+  /**
+   * Connect to Qwen service and establish session
+   *
+   * @param connection - ACP connection instance
+   * @param sessionReader - Session reader instance
+   * @param workingDir - Working directory
+   * @param authStateManager - Authentication state manager (optional)
+   * @param cliPath - CLI path (optional, if provided will override the path in configuration)
+   */
+  async connect(
+    connection: AcpConnection,
+    sessionReader: QwenSessionReader,
+    workingDir: string,
+    authStateManager?: AuthStateManager,
+    cliPath?: string,
+  ): Promise<void> {
+    const connectId = Date.now();
+    console.log(`[QwenAgentManager] 🚀 CONNECT() CALLED - ID: ${connectId}`);
+
+    // Check CLI version and features
+    const cliVersionManager = CliVersionManager.getInstance();
+    const versionInfo = await cliVersionManager.detectCliVersion();
+    console.log('[QwenAgentManager] CLI version info:', versionInfo);
+
+    // Store CLI context
+    const cliContextManager = CliContextManager.getInstance();
+    cliContextManager.setCurrentVersionInfo(versionInfo);
+
+    // Show warning if CLI version is below minimum requirement
+    if (!versionInfo.isSupported) {
+      // Wait to determine release version number
+      vscode.window.showWarningMessage(
+        `Qwen Code CLI version ${versionInfo.version} is below the minimum required version. Some features may not work properly. Please upgrade to version ${MIN_CLI_VERSION_FOR_SESSION_METHODS} or later.`,
+      );
+    }
+
+    const config = vscode.workspace.getConfiguration('qwenCode');
+    // Use the provided CLI path if available, otherwise use the configured path
+    const effectiveCliPath =
+      cliPath || config.get<string>('qwen.cliPath', 'qwen');
+
+    // Build extra CLI arguments (only essential parameters)
+    const extraArgs: string[] = [];
+
+    await connection.connect(effectiveCliPath, workingDir, extraArgs);
+
+    // Check if we have valid cached authentication
+    if (authStateManager) {
+      console.log('[QwenAgentManager] Checking for cached authentication...');
+      console.log('[QwenAgentManager] Working dir:', workingDir);
+      console.log('[QwenAgentManager] Auth method:', authMethod);
+
+      const hasValidAuth = await authStateManager.hasValidAuth(
+        workingDir,
+        authMethod,
+      );
+      console.log('[QwenAgentManager] Has valid auth:', hasValidAuth);
+    } else {
+      console.log('[QwenAgentManager] No authStateManager provided');
+    }
+
+    // Try to restore existing session or create new session
+    // Note: Auto-restore on connect is disabled to avoid surprising loads
+    // when user opens a "New Chat" tab. Restoration is now an explicit action
+    // (session selector → session/load) or handled by higher-level flows.
+    const sessionRestored = false;
+
+    // Create new session if unable to restore
+    if (!sessionRestored) {
+      console.log(
+        '[QwenAgentManager] no sessionRestored, Creating new session...',
+      );
+
+      // Check if we have valid cached authentication
+      let hasValidAuth = false;
+      if (authStateManager) {
+        hasValidAuth = await authStateManager.hasValidAuth(
+          workingDir,
+          authMethod,
+        );
+      }
+
+      // Only authenticate if we don't have valid cached auth
+      if (!hasValidAuth) {
+        console.log(
+          '[QwenAgentManager] Authenticating before creating session...',
+        );
+        try {
+          await connection.authenticate(authMethod);
+          console.log('[QwenAgentManager] Authentication successful');
+
+          // Save auth state
+          if (authStateManager) {
+            console.log(
+              '[QwenAgentManager] Saving auth state after successful authentication',
+            );
+            console.log('[QwenAgentManager] Working dir for save:', workingDir);
+            console.log('[QwenAgentManager] Auth method for save:', authMethod);
+            await authStateManager.saveAuthState(workingDir, authMethod);
+            console.log('[QwenAgentManager] Auth state save completed');
+          }
+        } catch (authError) {
+          console.error('[QwenAgentManager] Authentication failed:', authError);
+          // Clear potentially invalid cache
+          if (authStateManager) {
+            console.log(
+              '[QwenAgentManager] Clearing auth cache due to authentication failure',
+            );
+            await authStateManager.clearAuthState();
+          }
+          throw authError;
+        }
+      } else {
+        console.log(
+          '[QwenAgentManager] Skipping authentication - using valid cached auth',
+        );
+      }
+
+      try {
+        console.log(
+          '[QwenAgentManager] Creating new session after authentication...',
+        );
+        await this.newSessionWithRetry(
+          connection,
+          workingDir,
+          3,
+          authMethod,
+          authStateManager,
+        );
+        console.log('[QwenAgentManager] New session created successfully');
+
+        // Ensure auth state is saved (prevent repeated authentication)
+        if (authStateManager) {
+          console.log(
+            '[QwenAgentManager] Saving auth state after successful session creation',
+          );
+          await authStateManager.saveAuthState(workingDir, authMethod);
+        }
+      } catch (sessionError) {
+        console.log(`\n⚠️ [SESSION FAILED] newSessionWithRetry threw error\n`);
+        console.log(`[QwenAgentManager] Error details:`, sessionError);
+
+        // Clear cache
+        if (authStateManager) {
+          console.log('[QwenAgentManager] Clearing auth cache due to failure');
+          await authStateManager.clearAuthState();
+        }
+
+        throw sessionError;
+      }
+    }
+
+    console.log(`\n========================================`);
+    console.log(`[QwenAgentManager] ✅ CONNECT() COMPLETED SUCCESSFULLY`);
+    console.log(`========================================\n`);
+  }
+
+  /**
+   * Create new session (with retry)
+   *
+   * @param connection - ACP connection instance
+   * @param workingDir - Working directory
+   * @param maxRetries - Maximum number of retries
+   */
+  private async newSessionWithRetry(
+    connection: AcpConnection,
+    workingDir: string,
+    maxRetries: number,
+    authMethod: string,
+    authStateManager?: AuthStateManager,
+  ): Promise<void> {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(
+          `[QwenAgentManager] Creating session (attempt ${attempt}/${maxRetries})...`,
+        );
+        await connection.newSession(workingDir);
+        console.log('[QwenAgentManager] Session created successfully');
+        return;
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        console.error(
+          `[QwenAgentManager] Session creation attempt ${attempt} failed:`,
+          errorMessage,
+        );
+
+        // If Qwen reports that authentication is required, try to
+        // authenticate on-the-fly once and retry without waiting.
+        const requiresAuth =
+          errorMessage.includes('Authentication required') ||
+          errorMessage.includes('(code: -32000)');
+        if (requiresAuth) {
+          console.log(
+            '[QwenAgentManager] Qwen requires authentication. Authenticating and retrying session/new...',
+          );
+          try {
+            await connection.authenticate(authMethod);
+            if (authStateManager) {
+              await authStateManager.saveAuthState(workingDir, authMethod);
+            }
+            // Retry immediately after successful auth
+            await connection.newSession(workingDir);
+            console.log(
+              '[QwenAgentManager] Session created successfully after auth',
+            );
+            return;
+          } catch (authErr) {
+            console.error(
+              '[QwenAgentManager] Re-authentication failed:',
+              authErr,
+            );
+            if (authStateManager) {
+              await authStateManager.clearAuthState();
+            }
+            // Fall through to retry logic below
+          }
+        }
+
+        if (attempt === maxRetries) {
+          throw new Error(
+            `Session creation failed after ${maxRetries} attempts: ${errorMessage}`,
+          );
+        }
+
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        console.log(`[QwenAgentManager] Retrying in ${delay}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+}

packages/vscode-ide-companion/src/services/qwenSessionManager.ts

@@ -0,0 +1,336 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import type { QwenSession, QwenMessage } from './qwenSessionReader.js';
+
+/**
+ * Qwen Session Manager
+ *
+ * This service provides direct filesystem access to save and load sessions
+ * without relying on the CLI's ACP session/save method.
+ *
+ * Note: This is primarily used as a fallback mechanism when ACP methods are
+ * unavailable or fail. In normal operation, ACP session/list and session/load
+ * should be preferred for consistency with the CLI.
+ */
+export class QwenSessionManager {
+  private qwenDir: string;
+
+  constructor() {
+    this.qwenDir = path.join(os.homedir(), '.qwen');
+  }
+
+  /**
+   * Calculate project hash (same as CLI)
+   * Qwen CLI uses SHA256 hash of the project path
+   */
+  private getProjectHash(workingDir: string): string {
+    return crypto.createHash('sha256').update(workingDir).digest('hex');
+  }
+
+  /**
+   * Get the session directory for a project
+   */
+  private getSessionDir(workingDir: string): string {
+    const projectHash = this.getProjectHash(workingDir);
+    return path.join(this.qwenDir, 'tmp', projectHash, 'chats');
+  }
+
+  /**
+   * Generate a new session ID
+   */
+  private generateSessionId(): string {
+    return crypto.randomUUID();
+  }
+
+  /**
+   * Save current conversation as a checkpoint (matching CLI's /chat save format)
+   * Creates checkpoint with BOTH conversationId and sessionId as tags for compatibility
+   *
+   * @param messages - Current conversation messages
+   * @param conversationId - Conversation ID (from VSCode extension)
+   * @param sessionId - Session ID (from CLI tmp session file, optional)
+   * @param workingDir - Current working directory
+   * @returns Checkpoint tag
+   */
+  async saveCheckpoint(
+    messages: QwenMessage[],
+    conversationId: string,
+    workingDir: string,
+    sessionId?: string,
+  ): Promise<string> {
+    try {
+      console.log('[QwenSessionManager] ===== SAVEPOINT START =====');
+      console.log('[QwenSessionManager] Conversation ID:', conversationId);
+      console.log(
+        '[QwenSessionManager] Session ID:',
+        sessionId || 'not provided',
+      );
+      console.log('[QwenSessionManager] Working dir:', workingDir);
+      console.log('[QwenSessionManager] Message count:', messages.length);
+
+      // Get project directory (parent of chats directory)
+      const projectHash = this.getProjectHash(workingDir);
+      console.log('[QwenSessionManager] Project hash:', projectHash);
+
+      const projectDir = path.join(this.qwenDir, 'tmp', projectHash);
+      console.log('[QwenSessionManager] Project dir:', projectDir);
+
+      if (!fs.existsSync(projectDir)) {
+        console.log('[QwenSessionManager] Creating project directory...');
+        fs.mkdirSync(projectDir, { recursive: true });
+        console.log('[QwenSessionManager] Directory created');
+      } else {
+        console.log('[QwenSessionManager] Project directory already exists');
+      }
+
+      // Convert messages to checkpoint format (Gemini-style messages)
+      console.log(
+        '[QwenSessionManager] Converting messages to checkpoint format...',
+      );
+      const checkpointMessages = messages.map((msg, index) => {
+        console.log(
+          `[QwenSessionManager] Message ${index}: type=${msg.type}, contentLength=${msg.content?.length || 0}`,
+        );
+        return {
+          role: msg.type === 'user' ? 'user' : 'model',
+          parts: [
+            {
+              text: msg.content,
+            },
+          ],
+        };
+      });
+
+      console.log(
+        '[QwenSessionManager] Converted',
+        checkpointMessages.length,
+        'messages',
+      );
+
+      const jsonContent = JSON.stringify(checkpointMessages, null, 2);
+      console.log(
+        '[QwenSessionManager] JSON content length:',
+        jsonContent.length,
+      );
+
+      // Save with conversationId as primary tag
+      const convFilename = `checkpoint-${conversationId}.json`;
+      const convFilePath = path.join(projectDir, convFilename);
+      console.log(
+        '[QwenSessionManager] Saving checkpoint with conversationId:',
+        convFilePath,
+      );
+      fs.writeFileSync(convFilePath, jsonContent, 'utf-8');
+
+      // Also save with sessionId if provided (for compatibility with CLI session/load)
+      if (sessionId) {
+        const sessionFilename = `checkpoint-${sessionId}.json`;
+        const sessionFilePath = path.join(projectDir, sessionFilename);
+        console.log(
+          '[QwenSessionManager] Also saving checkpoint with sessionId:',
+          sessionFilePath,
+        );
+        fs.writeFileSync(sessionFilePath, jsonContent, 'utf-8');
+      }
+
+      // Verify primary file exists
+      if (fs.existsSync(convFilePath)) {
+        const stats = fs.statSync(convFilePath);
+        console.log(
+          '[QwenSessionManager] Primary checkpoint verified, size:',
+          stats.size,
+        );
+      } else {
+        console.error(
+          '[QwenSessionManager] ERROR: Primary checkpoint does not exist after write!',
+        );
+      }
+
+      console.log('[QwenSessionManager] ===== CHECKPOINT SAVED =====');
+      console.log('[QwenSessionManager] Primary path:', convFilePath);
+      if (sessionId) {
+        console.log(
+          '[QwenSessionManager] Secondary path (sessionId):',
+          path.join(projectDir, `checkpoint-${sessionId}.json`),
+        );
+      }
+      return conversationId;
+    } catch (error) {
+      console.error('[QwenSessionManager] ===== CHECKPOINT SAVE FAILED =====');
+      console.error('[QwenSessionManager] Error:', error);
+      console.error(
+        '[QwenSessionManager] Error stack:',
+        error instanceof Error ? error.stack : 'N/A',
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Save current conversation as a named session (checkpoint-like functionality)
+   *
+   * @param messages - Current conversation messages
+   * @param sessionName - Name/tag for the saved session
+   * @param workingDir - Current working directory
+   * @returns Session ID of the saved session
+   */
+  async saveSession(
+    messages: QwenMessage[],
+    sessionName: string,
+    workingDir: string,
+  ): Promise<string> {
+    try {
+      // Create session directory if it doesn't exist
+      const sessionDir = this.getSessionDir(workingDir);
+      if (!fs.existsSync(sessionDir)) {
+        fs.mkdirSync(sessionDir, { recursive: true });
+      }
+
+      // Generate session ID and filename using CLI's naming convention
+      const sessionId = this.generateSessionId();
+      const shortId = sessionId.split('-')[0]; // First part of UUID (8 chars)
+      const now = new Date();
+      const isoDate = now.toISOString().split('T')[0]; // YYYY-MM-DD
+      const isoTime = now
+        .toISOString()
+        .split('T')[1]
+        .split(':')
+        .slice(0, 2)
+        .join('-'); // HH-MM
+      const filename = `session-${isoDate}T${isoTime}-${shortId}.json`;
+      const filePath = path.join(sessionDir, filename);
+
+      // Create session object
+      const session: QwenSession = {
+        sessionId,
+        projectHash: this.getProjectHash(workingDir),
+        startTime: messages[0]?.timestamp || new Date().toISOString(),
+        lastUpdated: new Date().toISOString(),
+        messages,
+      };
+
+      // Save session to file
+      fs.writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf-8');
+
+      console.log(`[QwenSessionManager] Session saved: ${filePath}`);
+      return sessionId;
+    } catch (error) {
+      console.error('[QwenSessionManager] Failed to save session:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load a saved session by name
+   *
+   * @param sessionName - Name/tag of the session to load
+   * @param workingDir - Current working directory
+   * @returns Loaded session or null if not found
+   */
+  async loadSession(
+    sessionId: string,
+    workingDir: string,
+  ): Promise<QwenSession | null> {
+    try {
+      const sessionDir = this.getSessionDir(workingDir);
+      const filename = `session-${sessionId}.json`;
+      const filePath = path.join(sessionDir, filename);
+
+      if (!fs.existsSync(filePath)) {
+        console.log(`[QwenSessionManager] Session file not found: ${filePath}`);
+        return null;
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const session = JSON.parse(content) as QwenSession;
+
+      console.log(`[QwenSessionManager] Session loaded: ${filePath}`);
+      return session;
+    } catch (error) {
+      console.error('[QwenSessionManager] Failed to load session:', error);
+      return null;
+    }
+  }
+
+  /**
+   * List all saved sessions
+   *
+   * @param workingDir - Current working directory
+   * @returns Array of session objects
+   */
+  async listSessions(workingDir: string): Promise<QwenSession[]> {
+    try {
+      const sessionDir = this.getSessionDir(workingDir);
+
+      if (!fs.existsSync(sessionDir)) {
+        return [];
+      }
+
+      const files = fs
+        .readdirSync(sessionDir)
+        .filter(
+          (file) => file.startsWith('session-') && file.endsWith('.json'),
+        );
+
+      const sessions: QwenSession[] = [];
+      for (const file of files) {
+        try {
+          const filePath = path.join(sessionDir, file);
+          const content = fs.readFileSync(filePath, 'utf-8');
+          const session = JSON.parse(content) as QwenSession;
+          sessions.push(session);
+        } catch (error) {
+          console.error(
+            `[QwenSessionManager] Failed to read session file ${file}:`,
+            error,
+          );
+        }
+      }
+
+      // Sort by last updated time (newest first)
+      sessions.sort(
+        (a, b) =>
+          new Date(b.lastUpdated).getTime() - new Date(a.lastUpdated).getTime(),
+      );
+
+      return sessions;
+    } catch (error) {
+      console.error('[QwenSessionManager] Failed to list sessions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Delete a saved session
+   *
+   * @param sessionId - ID of the session to delete
+   * @param workingDir - Current working directory
+   * @returns True if deleted successfully, false otherwise
+   */
+  async deleteSession(sessionId: string, workingDir: string): Promise<boolean> {
+    try {
+      const sessionDir = this.getSessionDir(workingDir);
+      const filename = `session-${sessionId}.json`;
+      const filePath = path.join(sessionDir, filename);
+
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        console.log(`[QwenSessionManager] Session deleted: ${filePath}`);
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      console.error('[QwenSessionManager] Failed to delete session:', error);
+      return false;
+    }
+  }
+}

packages/vscode-ide-companion/src/services/qwenSessionReader.ts

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface QwenMessage {
+  id: string;
+  timestamp: string;
+  type: 'user' | 'qwen';
+  content: string;
+  thoughts?: unknown[];
+  tokens?: {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts: number;
+    tool: number;
+    total: number;
+  };
+  model?: string;
+}
+
+export interface QwenSession {
+  sessionId: string;
+  projectHash: string;
+  startTime: string;
+  lastUpdated: string;
+  messages: QwenMessage[];
+  filePath?: string;
+}
+
+export class QwenSessionReader {
+  private qwenDir: string;
+
+  constructor() {
+    this.qwenDir = path.join(os.homedir(), '.qwen');
+  }
+
+  /**
+   * Get all session list (optional: current project only or all projects)
+   */
+  async getAllSessions(
+    workingDir?: string,
+    allProjects: boolean = false,
+  ): Promise<QwenSession[]> {
+    try {
+      const sessions: QwenSession[] = [];
+
+      if (!allProjects && workingDir) {
+        // Current project only
+        const projectHash = await this.getProjectHash(workingDir);
+        const chatsDir = path.join(this.qwenDir, 'tmp', projectHash, 'chats');
+        const projectSessions = await this.readSessionsFromDir(chatsDir);
+        sessions.push(...projectSessions);
+      } else {
+        // All projects
+        const tmpDir = path.join(this.qwenDir, 'tmp');
+        if (!fs.existsSync(tmpDir)) {
+          console.log('[QwenSessionReader] Tmp directory not found:', tmpDir);
+          return [];
+        }
+
+        const projectDirs = fs.readdirSync(tmpDir);
+        for (const projectHash of projectDirs) {
+          const chatsDir = path.join(tmpDir, projectHash, 'chats');
+          const projectSessions = await this.readSessionsFromDir(chatsDir);
+          sessions.push(...projectSessions);
+        }
+      }
+
+      // Sort by last updated time
+      sessions.sort(
+        (a, b) =>
+          new Date(b.lastUpdated).getTime() - new Date(a.lastUpdated).getTime(),
+      );
+
+      return sessions;
+    } catch (error) {
+      console.error('[QwenSessionReader] Failed to get sessions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Read all sessions from specified directory
+   */
+  private async readSessionsFromDir(chatsDir: string): Promise<QwenSession[]> {
+    const sessions: QwenSession[] = [];
+
+    if (!fs.existsSync(chatsDir)) {
+      return sessions;
+    }
+
+    const files = fs
+      .readdirSync(chatsDir)
+      .filter((f) => f.startsWith('session-') && f.endsWith('.json'));
+
+    for (const file of files) {
+      const filePath = path.join(chatsDir, file);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const session = JSON.parse(content) as QwenSession;
+        session.filePath = filePath;
+        sessions.push(session);
+      } catch (error) {
+        console.error(
+          '[QwenSessionReader] Failed to read session file:',
+          filePath,
+          error,
+        );
+      }
+    }
+
+    return sessions;
+  }
+
+  /**
+   * Get details of specific session
+   */
+  async getSession(
+    sessionId: string,
+    _workingDir?: string,
+  ): Promise<QwenSession | null> {
+    // First try to find in all projects
+    const sessions = await this.getAllSessions(undefined, true);
+    return sessions.find((s) => s.sessionId === sessionId) || null;
+  }
+
+  /**
+   * Calculate project hash (needs to be consistent with Qwen CLI)
+   * Qwen CLI uses SHA256 hash of project path
+   */
+  private async getProjectHash(workingDir: string): Promise<string> {
+    const crypto = await import('crypto');
+    return crypto.createHash('sha256').update(workingDir).digest('hex');
+  }
+
+  /**
+   * Get session title (based on first user message)
+   */
+  getSessionTitle(session: QwenSession): string {
+    const firstUserMessage = session.messages.find((m) => m.type === 'user');
+    if (firstUserMessage) {
+      // Extract first 50 characters as title
+      return (
+        firstUserMessage.content.substring(0, 50) +
+        (firstUserMessage.content.length > 50 ? '...' : '')
+      );
+    }
+    return 'Untitled Session';
+  }
+
+  /**
+   * Delete session file
+   */
+  async deleteSession(
+    sessionId: string,
+    _workingDir: string,
+  ): Promise<boolean> {
+    try {
+      const session = await this.getSession(sessionId, _workingDir);
+      if (session && session.filePath) {
+        fs.unlinkSync(session.filePath);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('[QwenSessionReader] Failed to delete session:', error);
+      return false;
+    }
+  }
+}

packages/vscode-ide-companion/src/services/qwenSessionUpdateHandler.ts

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Qwen Session Update Handler
+ *
+ * Handles session updates from ACP and dispatches them to appropriate callbacks
+ */
+
+import type { AcpSessionUpdate, ApprovalModeValue } from '../types/acpTypes.js';
+import type { QwenAgentCallbacks } from '../types/chatTypes.js';
+
+/**
+ * Qwen Session Update Handler class
+ * Processes various session update events and calls appropriate callbacks
+ */
+export class QwenSessionUpdateHandler {
+  private callbacks: QwenAgentCallbacks;
+
+  constructor(callbacks: QwenAgentCallbacks) {
+    this.callbacks = callbacks;
+  }
+
+  /**
+   * Update callbacks
+   *
+   * @param callbacks - New callback collection
+   */
+  updateCallbacks(callbacks: QwenAgentCallbacks): void {
+    this.callbacks = callbacks;
+  }
+
+  /**
+   * Handle session update
+   *
+   * @param data - ACP session update data
+   */
+  handleSessionUpdate(data: AcpSessionUpdate): void {
+    const update = data.update;
+    console.log(
+      '[SessionUpdateHandler] Processing update type:',
+      update.sessionUpdate,
+    );
+
+    switch (update.sessionUpdate) {
+      case 'user_message_chunk':
+        if (update.content?.text && this.callbacks.onStreamChunk) {
+          this.callbacks.onStreamChunk(update.content.text);
+        }
+        break;
+
+      case 'agent_message_chunk':
+        if (update.content?.text && this.callbacks.onStreamChunk) {
+          this.callbacks.onStreamChunk(update.content.text);
+        }
+        break;
+
+      case 'agent_thought_chunk':
+        if (update.content?.text) {
+          if (this.callbacks.onThoughtChunk) {
+            this.callbacks.onThoughtChunk(update.content.text);
+          } else if (this.callbacks.onStreamChunk) {
+            // Fallback to regular stream processing
+            console.log(
+              '[SessionUpdateHandler] 🧠 Falling back to onStreamChunk',
+            );
+            this.callbacks.onStreamChunk(update.content.text);
+          }
+        }
+        break;
+
+      case 'tool_call': {
+        // Handle new tool call
+        if (this.callbacks.onToolCall && 'toolCallId' in update) {
+          this.callbacks.onToolCall({
+            toolCallId: update.toolCallId as string,
+            kind: (update.kind as string) || undefined,
+            title: (update.title as string) || undefined,
+            status: (update.status as string) || undefined,
+            rawInput: update.rawInput,
+            content: update.content as
+              | Array<Record<string, unknown>>
+              | undefined,
+            locations: update.locations as
+              | Array<{ path: string; line?: number | null }>
+              | undefined,
+          });
+        }
+        break;
+      }
+
+      case 'tool_call_update': {
+        if (this.callbacks.onToolCall && 'toolCallId' in update) {
+          this.callbacks.onToolCall({
+            toolCallId: update.toolCallId as string,
+            kind: (update.kind as string) || undefined,
+            title: (update.title as string) || undefined,
+            status: (update.status as string) || undefined,
+            rawInput: update.rawInput,
+            content: update.content as
+              | Array<Record<string, unknown>>
+              | undefined,
+            locations: update.locations as
+              | Array<{ path: string; line?: number | null }>
+              | undefined,
+          });
+        }
+        break;
+      }
+
+      case 'plan': {
+        if ('entries' in update) {
+          const entries = update.entries as Array<{
+            content: string;
+            priority: 'high' | 'medium' | 'low';
+            status: 'pending' | 'in_progress' | 'completed';
+          }>;
+
+          if (this.callbacks.onPlan) {
+            this.callbacks.onPlan(entries);
+          } else if (this.callbacks.onStreamChunk) {
+            // Fallback to stream processing
+            const planText =
+              '\n📋 Plan:\n' +
+              entries
+                .map(
+                  (entry, i) =>
+                    `${i + 1}. [${entry.priority}] ${entry.content}`,
+                )
+                .join('\n');
+            this.callbacks.onStreamChunk(planText);
+          }
+        }
+        break;
+      }
+
+      case 'current_mode_update': {
+        // Notify UI about mode change
+        try {
+          const modeId = (update as unknown as { modeId?: ApprovalModeValue })
+            .modeId;
+          if (modeId && this.callbacks.onModeChanged) {
+            this.callbacks.onModeChanged(modeId);
+          }
+        } catch (err) {
+          console.warn(
+            '[SessionUpdateHandler] Failed to handle mode update',
+            err,
+          );
+        }
+        break;
+      }
+
+      default:
+        console.log('[QwenAgentManager] Unhandled session update type');
+        break;
+    }
+  }
+}

packages/vscode-ide-companion/src/types/acpTypes.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const JSONRPC_VERSION = '2.0' as const;
+export const authMethod = 'qwen-oauth';
+
+export interface AcpRequest {
+  jsonrpc: typeof JSONRPC_VERSION;
+  id: number;
+  method: string;
+  params?: unknown;
+}
+
+export interface AcpResponse {
+  jsonrpc: typeof JSONRPC_VERSION;
+  id: number;
+  result?: unknown;
+  capabilities?: {
+    [key: string]: unknown;
+  };
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export interface AcpNotification {
+  jsonrpc: typeof JSONRPC_VERSION;
+  method: string;
+  params?: unknown;
+}
+
+export interface BaseSessionUpdate {
+  sessionId: string;
+}
+
+// Content block type (simplified version, use schema.ContentBlock for validation)
+export interface ContentBlock {
+  type: 'text' | 'image';
+  text?: string;
+  data?: string;
+  mimeType?: string;
+  uri?: string;
+}
+
+export interface UserMessageChunkUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'user_message_chunk';
+    content: ContentBlock;
+  };
+}
+
+export interface AgentMessageChunkUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'agent_message_chunk';
+    content: ContentBlock;
+  };
+}
+
+export interface AgentThoughtChunkUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'agent_thought_chunk';
+    content: ContentBlock;
+  };
+}
+
+export interface ToolCallUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'tool_call';
+    toolCallId: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    title: string;
+    kind:
+      | 'read'
+      | 'edit'
+      | 'execute'
+      | 'delete'
+      | 'move'
+      | 'search'
+      | 'fetch'
+      | 'think'
+      | 'other';
+    rawInput?: unknown;
+    content?: Array<{
+      type: 'content' | 'diff';
+      content?: {
+        type: 'text';
+        text: string;
+      };
+      path?: string;
+      oldText?: string | null;
+      newText?: string;
+    }>;
+    locations?: Array<{
+      path: string;
+      line?: number | null;
+    }>;
+  };
+}
+
+export interface ToolCallStatusUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'tool_call_update';
+    toolCallId: string;
+    status?: 'pending' | 'in_progress' | 'completed' | 'failed';
+    title?: string;
+    kind?: string;
+    rawInput?: unknown;
+    content?: Array<{
+      type: 'content' | 'diff';
+      content?: {
+        type: 'text';
+        text: string;
+      };
+      path?: string;
+      oldText?: string | null;
+      newText?: string;
+    }>;
+    locations?: Array<{
+      path: string;
+      line?: number | null;
+    }>;
+  };
+}
+
+export interface PlanUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'plan';
+    entries: Array<{
+      content: string;
+      priority: 'high' | 'medium' | 'low';
+      status: 'pending' | 'in_progress' | 'completed';
+    }>;
+  };
+}
+
+export type ApprovalModeValue = 'plan' | 'default' | 'auto-edit' | 'yolo';
+
+export {
+  ApprovalMode,
+  APPROVAL_MODE_MAP,
+  APPROVAL_MODE_INFO,
+  getApprovalModeInfoFromString,
+} from './approvalModeTypes.js';
+
+// Cyclic next-mode mapping used by UI toggles and other consumers
+export const NEXT_APPROVAL_MODE: {
+  [k in ApprovalModeValue]: ApprovalModeValue;
+} = {
+  // Hide "plan" from the public toggle sequence for now
+  // Cycle: default -> auto-edit -> yolo -> default
+  default: 'auto-edit',
+  'auto-edit': 'yolo',
+  plan: 'yolo',
+  yolo: 'default',
+};
+
+// Current mode update (sent by agent when mode changes)
+export interface CurrentModeUpdate extends BaseSessionUpdate {
+  update: {
+    sessionUpdate: 'current_mode_update';
+    modeId: ApprovalModeValue;
+  };
+}
+
+export type AcpSessionUpdate =
+  | UserMessageChunkUpdate
+  | AgentMessageChunkUpdate
+  | AgentThoughtChunkUpdate
+  | ToolCallUpdate
+  | ToolCallStatusUpdate
+  | PlanUpdate
+  | CurrentModeUpdate;
+
+// Permission request (simplified version, use schema.RequestPermissionRequest for validation)
+export interface AcpPermissionRequest {
+  sessionId: string;
+  options: Array<{
+    optionId: string;
+    name: string;
+    kind: 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+  }>;
+  toolCall: {
+    toolCallId: string;
+    rawInput?: {
+      command?: string;
+      description?: string;
+      [key: string]: unknown;
+    };
+    title?: string;
+    kind?: string;
+  };
+}
+
+export type AcpMessage =
+  | AcpRequest
+  | AcpNotification
+  | AcpResponse
+  | AcpSessionUpdate;

packages/vscode-ide-companion/src/types/approvalModeTypes.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Enum for approval modes with UI-friendly labels
+ * Represents the different approval modes available in the ACP protocol
+ * with their corresponding user-facing display names
+ */
+export enum ApprovalMode {
+  PLAN = 'plan',
+  DEFAULT = 'default',
+  AUTO_EDIT = 'auto-edit',
+  YOLO = 'yolo',
+}
+
+/**
+ * Mapping from string values to enum values for runtime conversion
+ */
+export const APPROVAL_MODE_MAP: Record<string, ApprovalMode> = {
+  plan: ApprovalMode.PLAN,
+  default: ApprovalMode.DEFAULT,
+  'auto-edit': ApprovalMode.AUTO_EDIT,
+  yolo: ApprovalMode.YOLO,
+};
+
+/**
+ * UI display information for each approval mode
+ */
+export const APPROVAL_MODE_INFO: Record<
+  ApprovalMode,
+  {
+    label: string;
+    title: string;
+    iconType?: 'edit' | 'auto' | 'plan' | 'yolo';
+  }
+> = {
+  [ApprovalMode.PLAN]: {
+    label: 'Plan mode',
+    title: 'Qwen will plan before executing. Click to switch modes.',
+    iconType: 'plan',
+  },
+  [ApprovalMode.DEFAULT]: {
+    label: 'Ask before edits',
+    title: 'Qwen will ask before each edit. Click to switch modes.',
+    iconType: 'edit',
+  },
+  [ApprovalMode.AUTO_EDIT]: {
+    label: 'Edit automatically',
+    title: 'Qwen will edit files automatically. Click to switch modes.',
+    iconType: 'auto',
+  },
+  [ApprovalMode.YOLO]: {
+    label: 'YOLO',
+    title: 'Automatically approve all tools. Click to switch modes.',
+    iconType: 'yolo',
+  },
+};
+
+/**
+ * Get UI display information for an approval mode from string value
+ */
+export function getApprovalModeInfoFromString(mode: string): {
+  label: string;
+  title: string;
+  iconType?: 'edit' | 'auto' | 'plan' | 'yolo';
+} {
+  const enumValue = APPROVAL_MODE_MAP[mode];
+  if (enumValue !== undefined) {
+    return APPROVAL_MODE_INFO[enumValue];
+  }
+  return {
+    label: 'Unknown mode',
+    title: 'Unknown edit mode',
+    iconType: undefined,
+  };
+}

packages/vscode-ide-companion/src/types/chatTypes.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AcpPermissionRequest, ApprovalModeValue } from './acpTypes.js';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: number;
+}
+
+export interface PlanEntry {
+  content: string;
+  priority?: 'high' | 'medium' | 'low';
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+export interface ToolCallUpdateData {
+  toolCallId: string;
+  kind?: string;
+  title?: string;
+  status?: string;
+  rawInput?: unknown;
+  content?: Array<Record<string, unknown>>;
+  locations?: Array<{ path: string; line?: number | null }>;
+}
+
+export interface QwenAgentCallbacks {
+  onMessage?: (message: ChatMessage) => void;
+  onStreamChunk?: (chunk: string) => void;
+  onThoughtChunk?: (chunk: string) => void;
+  onToolCall?: (update: ToolCallUpdateData) => void;
+  onPlan?: (entries: PlanEntry[]) => void;
+  onPermissionRequest?: (request: AcpPermissionRequest) => Promise<string>;
+  onEndTurn?: () => void;
+  onModeInfo?: (info: {
+    currentModeId?: ApprovalModeValue;
+    availableModes?: Array<{
+      id: ApprovalModeValue;
+      name: string;
+      description: string;
+    }>;
+  }) => void;
+  onModeChanged?: (modeId: ApprovalModeValue) => void;
+}
+
+export interface ToolCallUpdate {
+  type: 'tool_call' | 'tool_call_update';
+  toolCallId: string;
+  kind?: string;
+  title?: string;
+  status?: 'pending' | 'in_progress' | 'completed' | 'failed';
+  rawInput?: unknown;
+  content?: Array<{
+    type: 'content' | 'diff';
+    content?: {
+      type: string;
+      text?: string;
+      [key: string]: unknown;
+    };
+    path?: string;
+    oldText?: string | null;
+    newText?: string;
+    [key: string]: unknown;
+  }>;
+  locations?: Array<{
+    path: string;
+    line?: number | null;
+  }>;
+  timestamp?: number; // Add timestamp field for message ordering
+}

packages/vscode-ide-companion/src/types/completionItemTypes.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type React from 'react';
+
+export interface CompletionItem {
+  id: string;
+  label: string;
+  description?: string;
+  icon?: React.ReactNode;
+  type: 'file' | 'folder' | 'symbol' | 'command' | 'variable' | 'info';
+  // Value inserted into the input when selected (e.g., filename or command)
+  value?: string;
+  // Optional full path for files (used to build @filename -> full path mapping)
+  path?: string;
+}

packages/vscode-ide-companion/src/types/connectionTypes.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { ChildProcess } from 'child_process';
+import type { AcpSessionUpdate, AcpPermissionRequest } from './acpTypes.js';
+
+export interface PendingRequest<T = unknown> {
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+  timeoutId?: NodeJS.Timeout;
+  method: string;
+}
+
+export interface AcpConnectionCallbacks {
+  onSessionUpdate: (data: AcpSessionUpdate) => void;
+  onPermissionRequest: (data: AcpPermissionRequest) => Promise<{
+    optionId: string;
+  }>;
+  onEndTurn: () => void;
+}
+
+export interface AcpConnectionState {
+  child: ChildProcess | null;
+  pendingRequests: Map<number, PendingRequest<unknown>>;
+  nextRequestId: number;
+  sessionId: string | null;
+  isInitialized: boolean;
+}

packages/vscode-ide-companion/src/utils/editorGroupUtils.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import { openChatCommand } from '../commands/index.js';
+
+/**
+ * Find the editor group immediately to the left of the Qwen chat webview.
+ * - If the chat webview group is the leftmost group, returns undefined.
+ * - Uses the webview tab viewType 'mainThreadWebview-qwenCode.chat'.
+ */
+export function findLeftGroupOfChatWebview(): vscode.ViewColumn | undefined {
+  try {
+    const groups = vscode.window.tabGroups.all;
+
+    // Locate the group that contains our chat webview
+    const webviewGroup = groups.find((group) =>
+      group.tabs.some((tab) => {
+        const input: unknown = (tab as { input?: unknown }).input;
+        const isWebviewInput = (inp: unknown): inp is { viewType: string } =>
+          !!inp && typeof inp === 'object' && 'viewType' in inp;
+        return (
+          isWebviewInput(input) &&
+          input.viewType === 'mainThreadWebview-qwenCode.chat'
+        );
+      }),
+    );
+
+    if (!webviewGroup) {
+      return undefined;
+    }
+
+    // Among all groups to the left (smaller viewColumn), choose the one with
+    // the largest viewColumn value (i.e. the immediate neighbor on the left).
+    let candidate:
+      | { group: vscode.TabGroup; viewColumn: vscode.ViewColumn }
+      | undefined;
+    for (const g of groups) {
+      if (g.viewColumn < webviewGroup.viewColumn) {
+        if (!candidate || g.viewColumn > candidate.viewColumn) {
+          candidate = { group: g, viewColumn: g.viewColumn };
+        }
+      }
+    }
+
+    return candidate?.viewColumn;
+  } catch (_err) {
+    // Best-effort only; fall back to default behavior if anything goes wrong
+    return undefined;
+  }
+}
+
+/**
+ * Ensure there is an editor group directly to the left of the Qwen chat webview.
+ * - If one exists, return its ViewColumn.
+ * - If none exists, focus the chat panel and create a new group on its left,
+ *   then return the new group's ViewColumn (which equals the chat's previous column).
+ * - If the chat webview cannot be located, returns undefined.
+ */
+export async function ensureLeftGroupOfChatWebview(): Promise<
+  vscode.ViewColumn | undefined
+> {
+  // First try to find an existing left neighbor
+  const existing = findLeftGroupOfChatWebview();
+  if (existing !== undefined) {
+    return existing;
+  }
+
+  // Locate the chat webview group
+  const groups = vscode.window.tabGroups.all;
+  const webviewGroup = groups.find((group) =>
+    group.tabs.some((tab) => {
+      const input: unknown = (tab as { input?: unknown }).input;
+      const isWebviewInput = (inp: unknown): inp is { viewType: string } =>
+        !!inp && typeof inp === 'object' && 'viewType' in inp;
+      return (
+        isWebviewInput(input) &&
+        input.viewType === 'mainThreadWebview-qwenCode.chat'
+      );
+    }),
+  );
+
+  if (!webviewGroup) {
+    return undefined;
+  }
+
+  const previousChatColumn = webviewGroup.viewColumn;
+
+  // Make the chat group active by revealing the panel
+  try {
+    await vscode.commands.executeCommand(openChatCommand);
+  } catch {
+    // Best-effort; continue even if this fails
+  }
+
+  // Create a new group to the left of the chat group
+  try {
+    await vscode.commands.executeCommand('workbench.action.newGroupLeft');
+  } catch {
+    // If we fail to create a group, fall back to default behavior
+    return undefined;
+  }
+
+  // Restore focus to chat (optional), so we don't disturb user focus
+  try {
+    await vscode.commands.executeCommand(openChatCommand);
+  } catch {
+    // Ignore
+  }
+
+  // The new left group's column equals the chat's previous column
+  return previousChatColumn;
+}

packages/vscode-ide-companion/src/webview/App.tsx

@@ -0,0 +1,749 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, {
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  useMemo,
+  useLayoutEffect,
+} from 'react';
+import { useVSCode } from './hooks/useVSCode.js';
+import { useSessionManagement } from './hooks/session/useSessionManagement.js';
+import { useFileContext } from './hooks/file/useFileContext.js';
+import { useMessageHandling } from './hooks/message/useMessageHandling.js';
+import { useToolCalls } from './hooks/useToolCalls.js';
+import { useWebViewMessages } from './hooks/useWebViewMessages.js';
+import { useMessageSubmit } from './hooks/useMessageSubmit.js';
+import type {
+  PermissionOption,
+  ToolCall as PermissionToolCall,
+} from './components/PermissionDrawer/PermissionRequest.js';
+import type { TextMessage } from './hooks/message/useMessageHandling.js';
+import type { ToolCallData } from './components/messages/toolcalls/ToolCall.js';
+import { PermissionDrawer } from './components/PermissionDrawer/PermissionDrawer.js';
+import { ToolCall } from './components/messages/toolcalls/ToolCall.js';
+import { hasToolCallOutput } from './components/messages/toolcalls/shared/utils.js';
+import { EmptyState } from './components/layout/EmptyState.js';
+import { type CompletionItem } from '../types/completionItemTypes.js';
+import { useCompletionTrigger } from './hooks/useCompletionTrigger.js';
+import { ChatHeader } from './components/layout/ChatHeader.js';
+import {
+  UserMessage,
+  AssistantMessage,
+  ThinkingMessage,
+  WaitingMessage,
+  InterruptedMessage,
+} from './components/messages/index.js';
+import { InputForm } from './components/layout/InputForm.js';
+import { SessionSelector } from './components/layout/SessionSelector.js';
+import { FileIcon, UserIcon } from './components/icons/index.js';
+import { ApprovalMode, NEXT_APPROVAL_MODE } from '../types/acpTypes.js';
+import type { ApprovalModeValue } from '../types/acpTypes.js';
+import type { PlanEntry } from '../types/chatTypes.js';
+
+export const App: React.FC = () => {
+  const vscode = useVSCode();
+
+  // Core hooks
+  const sessionManagement = useSessionManagement(vscode);
+  const fileContext = useFileContext(vscode);
+  const messageHandling = useMessageHandling();
+  const {
+    inProgressToolCalls,
+    completedToolCalls,
+    handleToolCallUpdate,
+    clearToolCalls,
+  } = useToolCalls();
+
+  // UI state
+  const [inputText, setInputText] = useState('');
+  const [permissionRequest, setPermissionRequest] = useState<{
+    options: PermissionOption[];
+    toolCall: PermissionToolCall;
+  } | null>(null);
+  const [planEntries, setPlanEntries] = useState<PlanEntry[]>([]);
+  const messagesEndRef = useRef<HTMLDivElement>(
+    null,
+  ) as React.RefObject<HTMLDivElement>;
+  // Scroll container for message list; used to keep the view anchored to the latest content
+  const messagesContainerRef = useRef<HTMLDivElement>(
+    null,
+  ) as React.RefObject<HTMLDivElement>;
+  const inputFieldRef = useRef<HTMLDivElement>(
+    null,
+  ) as React.RefObject<HTMLDivElement>;
+
+  const [editMode, setEditMode] = useState<ApprovalModeValue>(
+    ApprovalMode.DEFAULT,
+  );
+  const [thinkingEnabled, setThinkingEnabled] = useState(false);
+  const [isComposing, setIsComposing] = useState(false);
+  // When true, do NOT auto-attach the active editor file/selection to message context
+  const [skipAutoActiveContext, setSkipAutoActiveContext] = useState(false);
+
+  // Completion system
+  const getCompletionItems = React.useCallback(
+    async (trigger: '@' | '/', query: string): Promise<CompletionItem[]> => {
+      if (trigger === '@') {
+        if (!fileContext.hasRequestedFiles) {
+          fileContext.requestWorkspaceFiles();
+        }
+
+        const fileIcon = <FileIcon />;
+        const allItems: CompletionItem[] = fileContext.workspaceFiles.map(
+          (file) => ({
+            id: file.id,
+            label: file.label,
+            description: file.description,
+            type: 'file' as const,
+            icon: fileIcon,
+            // Insert filename after @, keep path for mapping
+            value: file.label,
+            path: file.path,
+          }),
+        );
+
+        if (query && query.length >= 1) {
+          fileContext.requestWorkspaceFiles(query);
+          const lowerQuery = query.toLowerCase();
+          return allItems.filter(
+            (item) =>
+              item.label.toLowerCase().includes(lowerQuery) ||
+              (item.description &&
+                item.description.toLowerCase().includes(lowerQuery)),
+          );
+        }
+
+        // If first time and still loading, show a placeholder
+        if (allItems.length === 0) {
+          return [
+            {
+              id: 'loading-files',
+              label: 'Searching files…',
+              description: 'Type to filter, or wait a moment…',
+              type: 'info' as const,
+            },
+          ];
+        }
+
+        return allItems;
+      } else {
+        // Handle slash commands
+        const commands: CompletionItem[] = [
+          {
+            id: 'login',
+            label: '/login',
+            description: 'Login to Qwen Code',
+            type: 'command',
+            icon: <UserIcon />,
+          },
+        ];
+
+        return commands.filter((cmd) =>
+          cmd.label.toLowerCase().includes(query.toLowerCase()),
+        );
+      }
+    },
+    [fileContext],
+  );
+
+  const completion = useCompletionTrigger(inputFieldRef, getCompletionItems);
+
+  // When workspace files update while menu open for @, refresh items so the first @ shows the list
+  // Note: Avoid depending on the entire `completion` object here, since its identity
+  // changes on every render which would retrigger this effect and can cause a refresh loop.
+  useEffect(() => {
+    if (completion.isOpen && completion.triggerChar === '@') {
+      // Only refresh items; do not change other completion state to avoid re-renders loops
+      completion.refreshCompletion();
+    }
+    // Only re-run when the actual data source changes, not on every render
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [fileContext.workspaceFiles, completion.isOpen, completion.triggerChar]);
+
+  // Message submission
+  const handleSubmit = useMessageSubmit({
+    inputText,
+    setInputText,
+    messageHandling,
+    fileContext,
+    skipAutoActiveContext,
+    vscode,
+    inputFieldRef,
+    isStreaming: messageHandling.isStreaming,
+  });
+
+  // Handle cancel/stop from the input bar
+  // Emit a cancel to the extension and immediately reflect interruption locally.
+  const handleCancel = useCallback(() => {
+    if (messageHandling.isStreaming || messageHandling.isWaitingForResponse) {
+      // Proactively end local states and add an 'Interrupted' line
+      try {
+        messageHandling.endStreaming?.();
+      } catch {
+        /* no-op */
+      }
+      try {
+        messageHandling.clearWaitingForResponse?.();
+      } catch {
+        /* no-op */
+      }
+      messageHandling.addMessage({
+        role: 'assistant',
+        content: 'Interrupted',
+        timestamp: Date.now(),
+      });
+    }
+    // Notify extension/agent to cancel server-side work
+    vscode.postMessage({
+      type: 'cancelStreaming',
+      data: {},
+    });
+  }, [messageHandling, vscode]);
+
+  // Message handling
+  useWebViewMessages({
+    sessionManagement,
+    fileContext,
+    messageHandling,
+    handleToolCallUpdate,
+    clearToolCalls,
+    setPlanEntries,
+    handlePermissionRequest: setPermissionRequest,
+    inputFieldRef,
+    setInputText,
+    setEditMode,
+  });
+
+  // Auto-scroll handling: keep the view pinned to bottom when new content arrives,
+  // but don't interrupt the user if they scrolled up.
+  // We track whether the user is currently "pinned" to the bottom (near the end).
+  const [pinnedToBottom, setPinnedToBottom] = useState(true);
+  const prevCountsRef = useRef({ msgLen: 0, inProgLen: 0, doneLen: 0 });
+
+  // Observe scroll position to know if user has scrolled away from the bottom.
+  useEffect(() => {
+    const container = messagesContainerRef.current;
+    if (!container) {
+      return;
+    }
+
+    const onScroll = () => {
+      // Use a small threshold so slight deltas don't flip the state.
+      // Note: there's extra bottom padding for the input area, so keep this a bit generous.
+      const threshold = 80; // px tolerance
+      const distanceFromBottom =
+        container.scrollHeight - (container.scrollTop + container.clientHeight);
+      setPinnedToBottom(distanceFromBottom <= threshold);
+    };
+
+    // Initialize once mounted so first render is correct
+    onScroll();
+    container.addEventListener('scroll', onScroll, { passive: true });
+    return () => container.removeEventListener('scroll', onScroll);
+  }, []);
+
+  // When content changes, if the user is pinned to bottom, keep it anchored there.
+  // Only smooth-scroll when new items are appended; do not smooth for streaming chunk updates.
+  useLayoutEffect(() => {
+    const container = messagesContainerRef.current;
+    if (!container) {
+      return;
+    }
+
+    // Detect whether new items were appended (vs. streaming chunk updates)
+    const prev = prevCountsRef.current;
+    const newMsg = messageHandling.messages.length > prev.msgLen;
+    const newInProg = inProgressToolCalls.length > prev.inProgLen;
+    const newDone = completedToolCalls.length > prev.doneLen;
+    prevCountsRef.current = {
+      msgLen: messageHandling.messages.length,
+      inProgLen: inProgressToolCalls.length,
+      doneLen: completedToolCalls.length,
+    };
+
+    if (!pinnedToBottom) {
+      // Do nothing if user scrolled away; avoid stealing scroll.
+      return;
+    }
+
+    const smooth = newMsg || newInProg || newDone; // avoid smooth on streaming chunks
+
+    // Anchor to the bottom on next frame to avoid layout thrash.
+    const raf = requestAnimationFrame(() => {
+      const top = container.scrollHeight - container.clientHeight;
+      // Use scrollTo to avoid cross-context issues with scrollIntoView.
+      container.scrollTo({ top, behavior: smooth ? 'smooth' : 'auto' });
+    });
+    return () => cancelAnimationFrame(raf);
+  }, [
+    pinnedToBottom,
+    messageHandling.messages,
+    inProgressToolCalls,
+    completedToolCalls,
+    messageHandling.isWaitingForResponse,
+    messageHandling.loadingMessage,
+    messageHandling.isStreaming,
+    planEntries,
+  ]);
+
+  // When the last rendered item resizes (e.g., images/code blocks load/expand),
+  // if we're pinned to bottom, keep it anchored there.
+  useEffect(() => {
+    const container = messagesContainerRef.current;
+    const endEl = messagesEndRef.current;
+    if (!container || !endEl) {
+      return;
+    }
+
+    const lastItem = endEl.previousElementSibling as HTMLElement | null;
+    if (!lastItem) {
+      return;
+    }
+
+    let frame = 0;
+    const ro = new ResizeObserver(() => {
+      if (!pinnedToBottom) {
+        return;
+      }
+      // Defer to next frame to avoid thrash during rapid size changes
+      cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(() => {
+        const top = container.scrollHeight - container.clientHeight;
+        container.scrollTo({ top });
+      });
+    });
+    ro.observe(lastItem);
+
+    return () => {
+      cancelAnimationFrame(frame);
+      ro.disconnect();
+    };
+  }, [
+    pinnedToBottom,
+    messageHandling.messages,
+    inProgressToolCalls,
+    completedToolCalls,
+  ]);
+
+  // Handle permission response
+  const handlePermissionResponse = useCallback(
+    (optionId: string) => {
+      // Forward the selected optionId directly to extension as ACP permission response
+      // Expected values include: 'proceed_once', 'proceed_always', 'cancel', 'proceed_always_server', etc.
+      vscode.postMessage({
+        type: 'permissionResponse',
+        data: { optionId },
+      });
+      setPermissionRequest(null);
+    },
+    [vscode],
+  );
+
+  // Handle completion selection
+  const handleCompletionSelect = useCallback(
+    (item: CompletionItem) => {
+      // Handle completion selection by inserting the value into the input field
+      const inputElement = inputFieldRef.current;
+      if (!inputElement) {
+        return;
+      }
+
+      // Ignore info items (placeholders like "Searching files…")
+      if (item.type === 'info') {
+        completion.closeCompletion();
+        return;
+      }
+
+      // Slash commands can execute immediately
+      if (item.type === 'command') {
+        const command = (item.label || '').trim();
+        if (command === '/login') {
+          vscode.postMessage({ type: 'login', data: {} });
+          completion.closeCompletion();
+          return;
+        }
+      }
+
+      // If selecting a file, add @filename -> fullpath mapping
+      if (item.type === 'file' && item.value && item.path) {
+        try {
+          fileContext.addFileReference(item.value, item.path);
+        } catch (err) {
+          console.warn('[App] addFileReference failed:', err);
+        }
+      }
+
+      const selection = window.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        return;
+      }
+
+      // Current text and cursor
+      const text = inputElement.textContent || '';
+      const range = selection.getRangeAt(0);
+
+      // Compute total text offset for contentEditable
+      let cursorPos = text.length;
+      if (range.startContainer === inputElement) {
+        const childIndex = range.startOffset;
+        let offset = 0;
+        for (
+          let i = 0;
+          i < childIndex && i < inputElement.childNodes.length;
+          i++
+        ) {
+          offset += inputElement.childNodes[i].textContent?.length || 0;
+        }
+        cursorPos = offset || text.length;
+      } else if (range.startContainer.nodeType === Node.TEXT_NODE) {
+        const walker = document.createTreeWalker(
+          inputElement,
+          NodeFilter.SHOW_TEXT,
+          null,
+        );
+        let offset = 0;
+        let found = false;
+        let node: Node | null = walker.nextNode();
+        while (node) {
+          if (node === range.startContainer) {
+            offset += range.startOffset;
+            found = true;
+            break;
+          }
+          offset += node.textContent?.length || 0;
+          node = walker.nextNode();
+        }
+        cursorPos = found ? offset : text.length;
+      }
+
+      // Replace from trigger to cursor with selected value
+      const textBeforeCursor = text.substring(0, cursorPos);
+      const atPos = textBeforeCursor.lastIndexOf('@');
+      const slashPos = textBeforeCursor.lastIndexOf('/');
+      const triggerPos = Math.max(atPos, slashPos);
+
+      if (triggerPos >= 0) {
+        const insertValue =
+          typeof item.value === 'string' ? item.value : String(item.label);
+        const newText =
+          text.substring(0, triggerPos + 1) + // keep the trigger symbol
+          insertValue +
+          ' ' +
+          text.substring(cursorPos);
+
+        // Update DOM and state, and move caret to end
+        inputElement.textContent = newText;
+        setInputText(newText);
+
+        const newRange = document.createRange();
+        const sel = window.getSelection();
+        newRange.selectNodeContents(inputElement);
+        newRange.collapse(false);
+        sel?.removeAllRanges();
+        sel?.addRange(newRange);
+      }
+
+      // Close the completion menu
+      completion.closeCompletion();
+    },
+    [completion, inputFieldRef, setInputText, fileContext, vscode],
+  );
+
+  // Handle attach context click
+  const handleAttachContextClick = useCallback(() => {
+    // Open native file picker (different from '@' completion which searches workspace files)
+    vscode.postMessage({
+      type: 'attachFile',
+      data: {},
+    });
+  }, [vscode]);
+
+  // Handle toggle edit mode (Default -> Auto-edit -> YOLO -> Default)
+  const handleToggleEditMode = useCallback(() => {
+    setEditMode((prev) => {
+      const next: ApprovalModeValue = NEXT_APPROVAL_MODE[prev];
+
+      // Notify extension to set approval mode via ACP
+      try {
+        vscode.postMessage({
+          type: 'setApprovalMode',
+          data: { modeId: next },
+        });
+      } catch {
+        /* no-op */
+      }
+      return next;
+    });
+  }, [vscode]);
+
+  // Handle toggle thinking
+  const handleToggleThinking = () => {
+    setThinkingEnabled((prev) => !prev);
+  };
+
+  // Create unified message array containing all types of messages and tool calls
+  const allMessages = useMemo<
+    Array<{
+      type: 'message' | 'in-progress-tool-call' | 'completed-tool-call';
+      data: TextMessage | ToolCallData;
+      timestamp: number;
+    }>
+  >(() => {
+    // Regular messages
+    const regularMessages = messageHandling.messages.map((msg) => ({
+      type: 'message' as const,
+      data: msg,
+      timestamp: msg.timestamp,
+    }));
+
+    // In-progress tool calls
+    const inProgressTools = inProgressToolCalls.map((toolCall) => ({
+      type: 'in-progress-tool-call' as const,
+      data: toolCall,
+      timestamp: toolCall.timestamp || Date.now(),
+    }));
+
+    // Completed tool calls
+    const completedTools = completedToolCalls
+      .filter(hasToolCallOutput)
+      .map((toolCall) => ({
+        type: 'completed-tool-call' as const,
+        data: toolCall,
+        timestamp: toolCall.timestamp || Date.now(),
+      }));
+
+    // Merge and sort by timestamp to ensure messages and tool calls are interleaved
+    return [...regularMessages, ...inProgressTools, ...completedTools].sort(
+      (a, b) => (a.timestamp || 0) - (b.timestamp || 0),
+    );
+  }, [messageHandling.messages, inProgressToolCalls, completedToolCalls]);
+
+  console.log('[App] Rendering messages:', allMessages);
+
+  // Render all messages and tool calls
+  const renderMessages = useCallback<() => React.ReactNode>(
+    () =>
+      allMessages.map((item, index) => {
+        switch (item.type) {
+          case 'message': {
+            const msg = item.data as TextMessage;
+            const handleFileClick = (path: string): void => {
+              vscode.postMessage({
+                type: 'openFile',
+                data: { path },
+              });
+            };
+
+            if (msg.role === 'thinking') {
+              return (
+                <ThinkingMessage
+                  key={`message-${index}`}
+                  content={msg.content || ''}
+                  timestamp={msg.timestamp || 0}
+                  onFileClick={handleFileClick}
+                />
+              );
+            }
+
+            if (msg.role === 'user') {
+              return (
+                <UserMessage
+                  key={`message-${index}`}
+                  content={msg.content || ''}
+                  timestamp={msg.timestamp || 0}
+                  onFileClick={handleFileClick}
+                  fileContext={msg.fileContext}
+                />
+              );
+            }
+
+            {
+              const content = (msg.content || '').trim();
+              if (content === 'Interrupted' || content === 'Tool interrupted') {
+                return (
+                  <InterruptedMessage key={`message-${index}`} text={content} />
+                );
+              }
+              return (
+                <AssistantMessage
+                  key={`message-${index}`}
+                  content={content}
+                  timestamp={msg.timestamp || 0}
+                  onFileClick={handleFileClick}
+                />
+              );
+            }
+          }
+
+          case 'in-progress-tool-call':
+          case 'completed-tool-call': {
+            const prev = allMessages[index - 1];
+            const next = allMessages[index + 1];
+            const isToolCallType = (
+              x: unknown,
+            ): x is { type: 'in-progress-tool-call' | 'completed-tool-call' } =>
+              !!x &&
+              typeof x === 'object' &&
+              'type' in (x as Record<string, unknown>) &&
+              ((x as { type: string }).type === 'in-progress-tool-call' ||
+                (x as { type: string }).type === 'completed-tool-call');
+            const isFirst = !isToolCallType(prev);
+            const isLast = !isToolCallType(next);
+            return (
+              <ToolCall
+                key={`toolcall-${(item.data as ToolCallData).toolCallId}-${item.type}`}
+                toolCall={item.data as ToolCallData}
+                isFirst={isFirst}
+                isLast={isLast}
+              />
+            );
+          }
+
+          default:
+            return null;
+        }
+      }),
+    [allMessages, vscode],
+  );
+
+  const hasContent =
+    messageHandling.messages.length > 0 ||
+    messageHandling.isStreaming ||
+    inProgressToolCalls.length > 0 ||
+    completedToolCalls.length > 0 ||
+    planEntries.length > 0 ||
+    allMessages.length > 0;
+
+  return (
+    <div className="chat-container">
+      <SessionSelector
+        visible={sessionManagement.showSessionSelector}
+        sessions={sessionManagement.filteredSessions}
+        currentSessionId={sessionManagement.currentSessionId}
+        searchQuery={sessionManagement.sessionSearchQuery}
+        onSearchChange={sessionManagement.setSessionSearchQuery}
+        onSelectSession={(sessionId) => {
+          sessionManagement.handleSwitchSession(sessionId);
+          sessionManagement.setSessionSearchQuery('');
+        }}
+        onClose={() => sessionManagement.setShowSessionSelector(false)}
+        hasMore={sessionManagement.hasMore}
+        isLoading={sessionManagement.isLoading}
+        onLoadMore={sessionManagement.handleLoadMoreSessions}
+      />
+
+      <ChatHeader
+        currentSessionTitle={sessionManagement.currentSessionTitle}
+        onLoadSessions={sessionManagement.handleLoadQwenSessions}
+        onNewSession={sessionManagement.handleNewQwenSession}
+      />
+
+      <div
+        ref={messagesContainerRef}
+        className="chat-messages messages-container flex-1 overflow-y-auto overflow-x-hidden pt-5 pr-5 pl-5 pb-[120px] flex flex-col relative min-w-0 focus:outline-none [&::-webkit-scrollbar]:w-2 [&::-webkit-scrollbar-track]:bg-transparent [&::-webkit-scrollbar-thumb]:bg-white/20 [&::-webkit-scrollbar-thumb]:rounded-sm [&::-webkit-scrollbar-thumb]:hover:bg-white/30 [&>*]:flex [&>*]:gap-0 [&>*]:items-start [&>*]:text-left [&>*]:py-2 [&>*:not(:last-child)]:pb-[8px] [&>*]:flex-col [&>*]:relative [&>*]:animate-[fadeIn_0.2s_ease-in]"
+      >
+        {!hasContent ? (
+          <EmptyState />
+        ) : (
+          <>
+            {/* Render all messages and tool calls */}
+            {renderMessages()}
+            {/* Flow-in persistent slot: keeps a small constant height so toggling */}
+            {/* the waiting message doesn't change list height to zero. When */}
+            {/* active, render the waiting message inline (not fixed). */}
+            <div className="waiting-message-slot min-h-[28px]">
+              {messageHandling.isWaitingForResponse &&
+                messageHandling.loadingMessage && (
+                  <WaitingMessage
+                    loadingMessage={messageHandling.loadingMessage}
+                  />
+                )}
+            </div>
+
+            <div ref={messagesEndRef} />
+          </>
+        )}
+      </div>
+
+      <InputForm
+        inputText={inputText}
+        inputFieldRef={inputFieldRef}
+        isStreaming={messageHandling.isStreaming}
+        isWaitingForResponse={messageHandling.isWaitingForResponse}
+        isComposing={isComposing}
+        editMode={editMode}
+        thinkingEnabled={thinkingEnabled}
+        activeFileName={fileContext.activeFileName}
+        activeSelection={fileContext.activeSelection}
+        skipAutoActiveContext={skipAutoActiveContext}
+        onInputChange={setInputText}
+        onCompositionStart={() => setIsComposing(true)}
+        onCompositionEnd={() => setIsComposing(false)}
+        onKeyDown={() => {}}
+        onSubmit={handleSubmit.handleSubmit}
+        onCancel={handleCancel}
+        onToggleEditMode={handleToggleEditMode}
+        onToggleThinking={handleToggleThinking}
+        onFocusActiveEditor={fileContext.focusActiveEditor}
+        onToggleSkipAutoActiveContext={() =>
+          setSkipAutoActiveContext((v) => !v)
+        }
+        onShowCommandMenu={async () => {
+          if (inputFieldRef.current) {
+            inputFieldRef.current.focus();
+
+            const selection = window.getSelection();
+            let position = { top: 0, left: 0 };
+
+            if (selection && selection.rangeCount > 0) {
+              try {
+                const range = selection.getRangeAt(0);
+                const rangeRect = range.getBoundingClientRect();
+                if (rangeRect.top > 0 && rangeRect.left > 0) {
+                  position = {
+                    top: rangeRect.top,
+                    left: rangeRect.left,
+                  };
+                } else {
+                  const inputRect =
+                    inputFieldRef.current.getBoundingClientRect();
+                  position = { top: inputRect.top, left: inputRect.left };
+                }
+              } catch (error) {
+                console.error('[App] Error getting cursor position:', error);
+                const inputRect = inputFieldRef.current.getBoundingClientRect();
+                position = { top: inputRect.top, left: inputRect.left };
+              }
+            } else {
+              const inputRect = inputFieldRef.current.getBoundingClientRect();
+              position = { top: inputRect.top, left: inputRect.left };
+            }
+
+            await completion.openCompletion('/', '', position);
+          }
+        }}
+        onAttachContext={handleAttachContextClick}
+        completionIsOpen={completion.isOpen}
+        completionItems={completion.items}
+        onCompletionSelect={handleCompletionSelect}
+        onCompletionClose={completion.closeCompletion}
+      />
+
+      {permissionRequest && (
+        <PermissionDrawer
+          isOpen={!!permissionRequest}
+          options={permissionRequest.options}
+          toolCall={permissionRequest.toolCall}
+          onResponse={handlePermissionResponse}
+          onClose={() => setPermissionRequest(null)}
+        />
+      )}
+    </div>
+  );
+};

packages/vscode-ide-companion/src/webview/MessageHandler.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { QwenAgentManager } from '../services/qwenAgentManager.js';
+import type { ConversationStore } from '../services/conversationStore.js';
+import { MessageRouter } from './handlers/MessageRouter.js';
+
+/**
+ * MessageHandler (Refactored Version)
+ * This is a lightweight wrapper class that internally uses MessageRouter and various sub-handlers
+ * Maintains interface compatibility with the original code
+ */
+export class MessageHandler {
+  private router: MessageRouter;
+
+  constructor(
+    agentManager: QwenAgentManager,
+    conversationStore: ConversationStore,
+    currentConversationId: string | null,
+    sendToWebView: (message: unknown) => void,
+  ) {
+    this.router = new MessageRouter(
+      agentManager,
+      conversationStore,
+      currentConversationId,
+      sendToWebView,
+    );
+  }
+
+  /**
+   * Route messages to the corresponding handler
+   */
+  async route(message: { type: string; data?: unknown }): Promise<void> {
+    await this.router.route(message);
+  }
+
+  /**
+   * Set current session ID
+   */
+  setCurrentConversationId(id: string | null): void {
+    this.router.setCurrentConversationId(id);
+  }
+
+  /**
+   * Get current session ID
+   */
+  getCurrentConversationId(): string | null {
+    return this.router.getCurrentConversationId();
+  }
+
+  /**
+   * Set permission handler
+   */
+  setPermissionHandler(
+    handler: (message: { type: string; data: { optionId: string } }) => void,
+  ): void {
+    this.router.setPermissionHandler(handler);
+  }
+
+  /**
+   * Set login handler
+   */
+  setLoginHandler(handler: () => Promise<void>): void {
+    this.router.setLoginHandler(handler);
+  }
+
+  /**
+   * Append stream content
+   */
+  appendStreamContent(chunk: string): void {
+    this.router.appendStreamContent(chunk);
+  }
+
+  /**
+   * Check if saving checkpoint
+   */
+  getIsSavingCheckpoint(): boolean {
+    return this.router.getIsSavingCheckpoint();
+  }
+}

packages/vscode-ide-companion/src/webview/PanelManager.ts

@@ -0,0 +1,385 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Panel and Tab Manager
+ * Responsible for managing the creation, display, and tab tracking of WebView Panels
+ */
+export class PanelManager {
+  private panel: vscode.WebviewPanel | null = null;
+  private panelTab: vscode.Tab | null = null;
+  // Best-effort tracking of the group (by view column) that currently hosts
+  // the Qwen webview. We update this when creating/revealing the panel and
+  // whenever we can capture the Tab from the tab model.
+  private panelGroupViewColumn: vscode.ViewColumn | null = null;
+
+  constructor(
+    private extensionUri: vscode.Uri,
+    private onPanelDispose: () => void,
+  ) {}
+
+  /**
+   * Get the current Panel
+   */
+  getPanel(): vscode.WebviewPanel | null {
+    return this.panel;
+  }
+
+  /**
+   * Set Panel (for restoration)
+   */
+  setPanel(panel: vscode.WebviewPanel): void {
+    console.log('[PanelManager] Setting panel for restoration');
+    this.panel = panel;
+  }
+
+  /**
+   * Create new WebView Panel
+   * @returns Whether it is a newly created Panel
+   */
+  async createPanel(): Promise<boolean> {
+    if (this.panel) {
+      return false; // Panel already exists
+    }
+
+    // First, check if there's an existing Qwen Code group
+    const existingGroup = this.findExistingQwenCodeGroup();
+
+    if (existingGroup) {
+      // If Qwen Code webview already exists in a locked group, create the new panel in that same group
+      console.log(
+        '[PanelManager] Found existing Qwen Code group, creating panel in same group',
+      );
+      this.panel = vscode.window.createWebviewPanel(
+        'qwenCode.chat',
+        'Qwen Code',
+        { viewColumn: existingGroup.viewColumn, preserveFocus: false },
+        {
+          enableScripts: true,
+          retainContextWhenHidden: true,
+          localResourceRoots: [
+            vscode.Uri.joinPath(this.extensionUri, 'dist'),
+            vscode.Uri.joinPath(this.extensionUri, 'assets'),
+          ],
+        },
+      );
+      // Track the group column hosting this panel
+      this.panelGroupViewColumn = existingGroup.viewColumn;
+    } else {
+      // If no existing Qwen Code group, create a new group to the right of the active editor group
+      try {
+        // Create a new group to the right of the current active group
+        await vscode.commands.executeCommand('workbench.action.newGroupRight');
+      } catch (error) {
+        console.warn(
+          '[PanelManager] Failed to create right editor group (continuing):',
+          error,
+        );
+        // Fallback: create in current group
+        const activeColumn =
+          vscode.window.activeTextEditor?.viewColumn || vscode.ViewColumn.One;
+        this.panel = vscode.window.createWebviewPanel(
+          'qwenCode.chat',
+          'Qwen Code',
+          { viewColumn: activeColumn, preserveFocus: false },
+          {
+            enableScripts: true,
+            retainContextWhenHidden: true,
+            localResourceRoots: [
+              vscode.Uri.joinPath(this.extensionUri, 'dist'),
+              vscode.Uri.joinPath(this.extensionUri, 'assets'),
+            ],
+          },
+        );
+        // Lock the group after creation
+        await this.autoLockEditorGroup();
+        return true;
+      }
+
+      // Get the new group's view column (should be the active one after creating right)
+      const newGroupColumn = vscode.window.tabGroups.activeTabGroup.viewColumn;
+
+      this.panel = vscode.window.createWebviewPanel(
+        'qwenCode.chat',
+        'Qwen Code',
+        { viewColumn: newGroupColumn, preserveFocus: false },
+        {
+          enableScripts: true,
+          retainContextWhenHidden: true,
+          localResourceRoots: [
+            vscode.Uri.joinPath(this.extensionUri, 'dist'),
+            vscode.Uri.joinPath(this.extensionUri, 'assets'),
+          ],
+        },
+      );
+
+      // Lock the group after creation
+      await this.autoLockEditorGroup();
+
+      // Track the newly created group's column
+      this.panelGroupViewColumn = newGroupColumn;
+    }
+
+    // Set panel icon to Qwen logo
+    this.panel.iconPath = vscode.Uri.joinPath(
+      this.extensionUri,
+      'assets',
+      'icon.png',
+    );
+
+    // Try to capture Tab info shortly after creation so we can track the
+    // precise group even if the user later drags the tab between groups.
+    this.captureTab();
+
+    return true; // New panel created
+  }
+
+  /**
+   * Find the group and view column where the existing Qwen Code webview is located
+   * @returns The found group and view column, or undefined if not found
+   */
+  private findExistingQwenCodeGroup():
+    | { group: vscode.TabGroup; viewColumn: vscode.ViewColumn }
+    | undefined {
+    for (const group of vscode.window.tabGroups.all) {
+      for (const tab of group.tabs) {
+        const input: unknown = (tab as { input?: unknown }).input;
+        const isWebviewInput = (inp: unknown): inp is { viewType: string } =>
+          !!inp && typeof inp === 'object' && 'viewType' in inp;
+
+        if (
+          isWebviewInput(input) &&
+          input.viewType === 'mainThreadWebview-qwenCode.chat'
+        ) {
+          // Found an existing Qwen Code tab
+          console.log('[PanelManager] Found existing Qwen Code group:', {
+            viewColumn: group.viewColumn,
+            tabCount: group.tabs.length,
+            isActive: group.isActive,
+          });
+          return {
+            group,
+            viewColumn: group.viewColumn,
+          };
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Auto-lock editor group (only called when creating a new Panel)
+   * After creating/revealing the WebviewPanel, lock the active editor group so
+   * the group stays dedicated (users can still unlock manually). We still
+   * temporarily unlock before creation to allow adding tabs to an existing
+   * group; this method restores the locked state afterwards.
+   */
+  async autoLockEditorGroup(): Promise<void> {
+    if (!this.panel) {
+      return;
+    }
+
+    try {
+      // The newly created panel is focused (preserveFocus: false), so this
+      // locks the correct, active editor group.
+      await vscode.commands.executeCommand('workbench.action.lockEditorGroup');
+      console.log('[PanelManager] Group locked after panel creation');
+    } catch (error) {
+      console.warn('[PanelManager] Failed to lock editor group:', error);
+    }
+  }
+
+  /**
+   * Show Panel (reveal if exists, otherwise do nothing)
+   * @param preserveFocus Whether to preserve focus
+   */
+  revealPanel(preserveFocus: boolean = true): void {
+    if (this.panel) {
+      // Prefer revealing in the currently tracked group to avoid reflowing groups.
+      const trackedColumn = (
+        this.panelTab as unknown as {
+          group?: { viewColumn?: vscode.ViewColumn };
+        }
+      )?.group?.viewColumn as vscode.ViewColumn | undefined;
+      const targetColumn: vscode.ViewColumn =
+        trackedColumn ??
+        this.panelGroupViewColumn ??
+        vscode.window.tabGroups.activeTabGroup.viewColumn;
+      this.panel.reveal(targetColumn, preserveFocus);
+    }
+  }
+
+  /**
+   * Capture the Tab corresponding to the WebView Panel
+   * Used for tracking and managing Tab state
+   */
+  captureTab(): void {
+    if (!this.panel) {
+      return;
+    }
+
+    // Defer slightly so the tab model is updated after create/reveal
+    setTimeout(() => {
+      const allTabs = vscode.window.tabGroups.all.flatMap((g) => g.tabs);
+      const match = allTabs.find((t) => {
+        // Type guard for webview tab input
+        const input: unknown = (t as { input?: unknown }).input;
+        const isWebviewInput = (inp: unknown): inp is { viewType: string } =>
+          !!inp && typeof inp === 'object' && 'viewType' in inp;
+        const isWebview = isWebviewInput(input);
+        const sameViewType = isWebview && input.viewType === 'qwenCode.chat';
+        const sameLabel = t.label === this.panel!.title;
+        return !!(sameViewType || sameLabel);
+      });
+      this.panelTab = match ?? null;
+      // Update last-known group column if we can read it from the captured tab
+      try {
+        const groupViewColumn = (
+          this.panelTab as unknown as {
+            group?: { viewColumn?: vscode.ViewColumn };
+          }
+        )?.group?.viewColumn;
+        if (groupViewColumn !== null) {
+          this.panelGroupViewColumn = groupViewColumn as vscode.ViewColumn;
+        }
+      } catch {
+        // Best effort only; ignore if the API shape differs
+      }
+    }, 50);
+  }
+
+  /**
+   * Register the dispose event handler for the Panel
+   * @param disposables Array used to store Disposable objects
+   */
+  registerDisposeHandler(disposables: vscode.Disposable[]): void {
+    if (!this.panel) {
+      return;
+    }
+
+    this.panel.onDidDispose(
+      () => {
+        // Capture the group we intend to clean up before we clear fields
+        const targetColumn: vscode.ViewColumn | null =
+          // Prefer the group from the captured tab if available
+          ((
+            this.panelTab as unknown as {
+              group?: { viewColumn?: vscode.ViewColumn };
+            }
+          )?.group?.viewColumn as vscode.ViewColumn | undefined) ??
+          // Fall back to our last-known group column
+          this.panelGroupViewColumn ??
+          null;
+
+        this.panel = null;
+        this.panelTab = null;
+        this.onPanelDispose();
+
+        // After VS Code updates its tab model, check if that group is now
+        // empty (and typically locked for Qwen). If so, close the group to
+        // avoid leaving an empty locked column when the user closes Qwen.
+        if (targetColumn !== null) {
+          const column: vscode.ViewColumn = targetColumn;
+          setTimeout(async () => {
+            try {
+              const groups = vscode.window.tabGroups.all;
+              const group = groups.find((g) => g.viewColumn === column);
+              // If the group that hosted Qwen is now empty, close it to avoid
+              // leaving an empty locked column around. VS Code's stable API
+              // does not expose the lock state on TabGroup, so we only check
+              // for emptiness here.
+              if (group && group.tabs.length === 0) {
+                // Focus the group we want to close
+                await this.focusGroupByColumn(column);
+                // Try closeGroup first; fall back to removeActiveEditorGroup
+                try {
+                  await vscode.commands.executeCommand(
+                    'workbench.action.closeGroup',
+                  );
+                } catch {
+                  try {
+                    await vscode.commands.executeCommand(
+                      'workbench.action.removeActiveEditorGroup',
+                    );
+                  } catch (err) {
+                    console.warn(
+                      '[PanelManager] Failed to close empty group after Qwen panel disposed:',
+                      err,
+                    );
+                  }
+                }
+              }
+            } catch (err) {
+              console.warn(
+                '[PanelManager] Error while trying to close empty Qwen group:',
+                err,
+              );
+            }
+          }, 50);
+        }
+      },
+      null,
+      disposables,
+    );
+  }
+
+  /**
+   * Focus the editor group at the given view column by stepping left/right.
+   * This avoids depending on Nth-group focus commands that may not exist.
+   */
+  private async focusGroupByColumn(target: vscode.ViewColumn): Promise<void> {
+    const maxHops = 20; // safety guard for unusual layouts
+    let hops = 0;
+    while (
+      vscode.window.tabGroups.activeTabGroup.viewColumn !== target &&
+      hops < maxHops
+    ) {
+      const current = vscode.window.tabGroups.activeTabGroup.viewColumn;
+      if (current < target) {
+        await vscode.commands.executeCommand(
+          'workbench.action.focusRightGroup',
+        );
+      } else if (current > target) {
+        await vscode.commands.executeCommand('workbench.action.focusLeftGroup');
+      } else {
+        break;
+      }
+      hops++;
+    }
+  }
+
+  /**
+   * Register the view state change event handler
+   * @param disposables Array used to store Disposable objects
+   */
+  registerViewStateChangeHandler(disposables: vscode.Disposable[]): void {
+    if (!this.panel) {
+      return;
+    }
+
+    this.panel.onDidChangeViewState(
+      () => {
+        if (this.panel && this.panel.visible) {
+          this.captureTab();
+        }
+      },
+      null,
+      disposables,
+    );
+  }
+
+  /**
+   * Dispose Panel
+   */
+  dispose(): void {
+    this.panel?.dispose();
+    this.panel = null;
+    this.panelTab = null;
+  }
+}

packages/vscode-ide-companion/src/webview/WebViewContent.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import { escapeHtml } from './utils/webviewUtils.js';
+
+/**
+ * WebView HTML Content Generator
+ * Responsible for generating the HTML content of the WebView
+ */
+export class WebViewContent {
+  /**
+   * Generate HTML content for the WebView
+   * @param panel WebView Panel
+   * @param extensionUri Extension URI
+   * @returns HTML string
+   */
+  static generate(
+    panel: vscode.WebviewPanel,
+    extensionUri: vscode.Uri,
+  ): string {
+    const scriptUri = panel.webview.asWebviewUri(
+      vscode.Uri.joinPath(extensionUri, 'dist', 'webview.js'),
+    );
+
+    // Convert extension URI for webview access - this allows frontend to construct resource paths
+    const extensionUriForWebview = panel.webview.asWebviewUri(extensionUri);
+
+    // Escape URI for HTML to prevent potential injection attacks
+    const safeExtensionUri = escapeHtml(extensionUriForWebview.toString());
+    const safeScriptUri = escapeHtml(scriptUri.toString());
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src ${panel.webview.cspSource}; script-src ${panel.webview.cspSource}; style-src ${panel.webview.cspSource} 'unsafe-inline';">
+  <title>Qwen Code</title>
+</head>
+<body data-extension-uri="${safeExtensionUri}">
+  <div id="root"></div>
+  <script src="${safeScriptUri}"></script>
+</body>
+</html>`;
+  }
+}

packages/vscode-ide-companion/src/webview/components/PermissionDrawer/PermissionDrawer.tsx

@@ -0,0 +1,312 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type React from 'react';
+import { useEffect, useState, useRef } from 'react';
+import type { PermissionOption, ToolCall } from './PermissionRequest.js';
+
+interface PermissionDrawerProps {
+  isOpen: boolean;
+  options: PermissionOption[];
+  toolCall: ToolCall;
+  onResponse: (optionId: string) => void;
+  onClose?: () => void;
+}
+
+export const PermissionDrawer: React.FC<PermissionDrawerProps> = ({
+  isOpen,
+  options,
+  toolCall,
+  onResponse,
+  onClose,
+}) => {
+  const [focusedIndex, setFocusedIndex] = useState(0);
+  const [customMessage, setCustomMessage] = useState('');
+  const containerRef = useRef<HTMLDivElement>(null);
+  // Correct the ref type for custom input to HTMLInputElement to avoid subsequent forced casting
+  const customInputRef = useRef<HTMLInputElement>(null);
+
+  console.log('PermissionDrawer rendered with isOpen:', isOpen, toolCall);
+  // Prefer file name from locations, fall back to content[].path if present
+  const getAffectedFileName = (): string => {
+    const fromLocations = toolCall.locations?.[0]?.path;
+    if (fromLocations) {
+      return fromLocations.split('/').pop() || fromLocations;
+    }
+    // Some tool calls (e.g. write/edit with diff content) only include path in content
+    const fromContent = Array.isArray(toolCall.content)
+      ? (
+          toolCall.content.find(
+            (c: unknown) =>
+              typeof c === 'object' &&
+              c !== null &&
+              'path' in (c as Record<string, unknown>),
+          ) as { path?: unknown } | undefined
+        )?.path
+      : undefined;
+    if (typeof fromContent === 'string' && fromContent.length > 0) {
+      return fromContent.split('/').pop() || fromContent;
+    }
+    return 'file';
+  };
+
+  // Get the title for the permission request
+  const getTitle = () => {
+    if (toolCall.kind === 'edit' || toolCall.kind === 'write') {
+      const fileName = getAffectedFileName();
+      return (
+        <>
+          Make this edit to{' '}
+          <span className="font-mono text-[var(--app-primary-foreground)]">
+            {fileName}
+          </span>
+          ?
+        </>
+      );
+    }
+    if (toolCall.kind === 'execute' || toolCall.kind === 'bash') {
+      return 'Allow this bash command?';
+    }
+    if (toolCall.kind === 'read') {
+      const fileName = getAffectedFileName();
+      return (
+        <>
+          Allow read from{' '}
+          <span className="font-mono text-[var(--app-primary-foreground)]">
+            {fileName}
+          </span>
+          ?
+        </>
+      );
+    }
+    return toolCall.title || 'Permission Required';
+  };
+
+  // Handle keyboard navigation
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (!isOpen) {
+        return;
+      }
+
+      // Number keys 1-9 for quick select
+      const numMatch = e.key.match(/^[1-9]$/);
+      if (
+        numMatch &&
+        !customInputRef.current?.contains(document.activeElement)
+      ) {
+        const index = parseInt(e.key, 10) - 1;
+        if (index < options.length) {
+          e.preventDefault();
+          onResponse(options[index].optionId);
+        }
+        return;
+      }
+
+      // Arrow keys for navigation
+      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+        e.preventDefault();
+        const totalItems = options.length + 1; // +1 for custom input
+        if (e.key === 'ArrowDown') {
+          setFocusedIndex((prev) => (prev + 1) % totalItems);
+        } else {
+          setFocusedIndex((prev) => (prev - 1 + totalItems) % totalItems);
+        }
+      }
+
+      // Enter to select
+      if (
+        e.key === 'Enter' &&
+        !customInputRef.current?.contains(document.activeElement)
+      ) {
+        e.preventDefault();
+        if (focusedIndex < options.length) {
+          onResponse(options[focusedIndex].optionId);
+        }
+      }
+
+      // Escape to cancel permission and close (align with CLI behavior)
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        const rejectOptionId =
+          options.find((o) => o.kind.includes('reject'))?.optionId ||
+          options.find((o) => o.optionId === 'cancel')?.optionId ||
+          'cancel';
+        onResponse(rejectOptionId);
+        if (onClose) {
+          onClose();
+        }
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [isOpen, options, onResponse, onClose, focusedIndex]);
+
+  // Focus container when opened
+  useEffect(() => {
+    if (isOpen && containerRef.current) {
+      containerRef.current.focus();
+    }
+  }, [isOpen]);
+
+  // Reset focus to the first option when the drawer opens or the options change
+  useEffect(() => {
+    if (isOpen) {
+      setFocusedIndex(0);
+    }
+  }, [isOpen, options.length]);
+
+  if (!isOpen) {
+    return null;
+  }
+
+  return (
+    <div className="fixed inset-x-0 bottom-0 z-[1000] p-2">
+      {/* Main container */}
+      <div
+        ref={containerRef}
+        className="relative flex flex-col rounded-large border p-2 outline-none animate-slide-up"
+        style={{
+          backgroundColor: 'var(--app-input-secondary-background)',
+          borderColor: 'var(--app-input-border)',
+        }}
+        tabIndex={0}
+        data-focused-index={focusedIndex}
+      >
+        {/* Background layer */}
+        <div
+          className="p-2 absolute inset-0 rounded-large"
+          style={{ backgroundColor: 'var(--app-input-background)' }}
+        />
+
+        {/* Title + Description (from toolCall.title) */}
+        <div className="relative z-[1] text-[1.1em] text-[var(--app-primary-foreground)] flex flex-col min-h-0">
+          <div className="font-bold text-[var(--app-primary-foreground)] mb-0.5">
+            {getTitle()}
+          </div>
+          {(toolCall.kind === 'edit' ||
+            toolCall.kind === 'write' ||
+            toolCall.kind === 'read' ||
+            toolCall.kind === 'execute' ||
+            toolCall.kind === 'bash') &&
+            toolCall.title && (
+              <div
+                /* 13px, normal font weight; normal whitespace wrapping + long word breaking; maximum 3 lines with overflow ellipsis */
+                className="text-[13px] font-normal text-[var(--app-secondary-foreground)] opacity-90 font-mono whitespace-normal break-words q-line-clamp-3 mb-2"
+                style={{
+                  fontSize: '.9em',
+                  color: 'var(--app-secondary-foreground)',
+                  marginBottom: '6px',
+                }}
+                title={toolCall.title}
+              >
+                {toolCall.title}
+              </div>
+            )}
+        </div>
+
+        {/* Options */}
+        <div className="relative z-[1] flex flex-col gap-1 pb-1">
+          {options.map((option, index) => {
+            const isFocused = focusedIndex === index;
+
+            return (
+              <button
+                key={option.optionId}
+                className={`flex items-center gap-2 px-2 py-1.5 text-left w-full box-border rounded-[4px] border-0 shadow-[inset_0_0_0_1px_var(--app-transparent-inner-border)] transition-colors duration-150 text-[var(--app-primary-foreground)] hover:bg-[var(--app-button-background)] ${
+                  isFocused
+                    ? 'text-[var(--app-list-active-foreground)] bg-[var(--app-list-active-background)] hover:text-[var(--app-button-foreground)] hover:font-bold hover:relative hover:border-0'
+                    : 'hover:bg-[var(--app-button-background)] hover:text-[var(--app-button-foreground)] hover:font-bold hover:relative hover:border-0'
+                }`}
+                onClick={() => onResponse(option.optionId)}
+                onMouseEnter={() => setFocusedIndex(index)}
+              >
+                {/* Number badge */}
+                <span className="inline-flex items-center justify-center min-w-[10px] h-5 font-semibold opacity-60">
+                  {index + 1}
+                </span>
+                {/* Option text */}
+                <span className="font-semibold">{option.name}</span>
+              </button>
+            );
+          })}
+
+          {/* Custom message input (extracted component) */}
+          {(() => {
+            const isFocused = focusedIndex === options.length;
+            const rejectOptionId = options.find((o) =>
+              o.kind.includes('reject'),
+            )?.optionId;
+            return (
+              <CustomMessageInputRow
+                isFocused={isFocused}
+                customMessage={customMessage}
+                setCustomMessage={setCustomMessage}
+                onFocusRow={() => setFocusedIndex(options.length)}
+                onSubmitReject={() => {
+                  if (rejectOptionId) {
+                    onResponse(rejectOptionId);
+                  }
+                }}
+                inputRef={customInputRef}
+              />
+            );
+          })()}
+        </div>
+      </div>
+
+      {/* Moved slide-up keyframes to Tailwind theme (tailwind.config.js) */}
+    </div>
+  );
+};
+
+/**
+ * CustomMessageInputRow: Reusable custom input row component (without hooks)
+ */
+interface CustomMessageInputRowProps {
+  isFocused: boolean;
+  customMessage: string;
+  setCustomMessage: (val: string) => void;
+  onFocusRow: () => void; // Set focus when mouse enters or input box is focused
+  onSubmitReject: () => void; // Triggered when Enter is pressed (selecting reject option)
+  inputRef: React.RefObject<HTMLInputElement | null>;
+}
+
+const CustomMessageInputRow: React.FC<CustomMessageInputRowProps> = ({
+  isFocused,
+  customMessage,
+  setCustomMessage,
+  onFocusRow,
+  onSubmitReject,
+  inputRef,
+}) => (
+  <div
+    className={`flex items-center gap-2 px-2 py-1.5 text-left w-full box-border rounded-[4px] border-0 shadow-[inset_0_0_0_1px_var(--app-transparent-inner-border)] cursor-text text-[var(--app-primary-foreground)] ${
+      isFocused ? 'text-[var(--app-list-active-foreground)]' : ''
+    }`}
+    onMouseEnter={onFocusRow}
+    onClick={() => inputRef.current?.focus()}
+  >
+    <input
+      ref={inputRef as React.LegacyRef<HTMLInputElement> | undefined}
+      type="text"
+      placeholder="Tell Qwen what to do instead"
+      spellCheck={false}
+      className="flex-1 bg-transparent border-0 outline-none text-sm placeholder:opacity-70"
+      style={{ color: 'var(--app-input-foreground)' }}
+      value={customMessage}
+      onChange={(e) => setCustomMessage(e.target.value)}
+      onFocus={onFocusRow}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter' && !e.shiftKey && customMessage.trim()) {
+          e.preventDefault();
+          onSubmitReject();
+        }
+      }}
+    />
+  </div>
+);

packages/vscode-ide-companion/src/webview/components/PermissionDrawer/PermissionRequest.tsx

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export interface PermissionOption {
+  name: string;
+  kind: string;
+  optionId: string;
+}
+
+export interface ToolCall {
+  title?: string;
+  kind?: string;
+  toolCallId?: string;
+  rawInput?: {
+    command?: string;
+    description?: string;
+    [key: string]: unknown;
+  };
+  content?: Array<{
+    type: string;
+    [key: string]: unknown;
+  }>;
+  locations?: Array<{
+    path: string;
+    line?: number | null;
+  }>;
+  status?: string;
+}
+
+export interface PermissionRequestProps {
+  options: PermissionOption[];
+  toolCall: ToolCall;
+  onResponse: (optionId: string) => void;
+}