chore(release): sdk-typescript v0.1.0-preview.0

test: separating integration tests for the CLI and SDK

.github/workflows/release-sdk.yml

@@ -0,0 +1,237 @@
+name: 'Release SDK'
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'The version to release (e.g., v0.1.11). Required for manual patch releases.'
+        required: false
+        type: 'string'
+      ref:
+        description: 'The branch or ref (full git sha) to release from.'
+        required: true
+        type: 'string'
+        default: 'main'
+      dry_run:
+        description: 'Run a dry-run of the release process; no branches, npm packages or GitHub releases will be created.'
+        required: true
+        type: 'boolean'
+        default: true
+      create_nightly_release:
+        description: 'Auto apply the nightly release tag, input version is ignored.'
+        required: false
+        type: 'boolean'
+        default: false
+      create_preview_release:
+        description: 'Auto apply the preview release tag, input version is ignored.'
+        required: false
+        type: 'boolean'
+        default: false
+      force_skip_tests:
+        description: 'Select to skip the "Run Tests" step in testing. Prod releases should run tests'
+        required: false
+        type: 'boolean'
+        default: false
+
+jobs:
+  release-sdk:
+    runs-on: 'ubuntu-latest'
+    environment:
+      name: 'production-release'
+      url: '${{ github.server_url }}/${{ github.repository }}/releases/tag/sdk-typescript-${{ steps.version.outputs.RELEASE_TAG }}'
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
+    permissions:
+      contents: 'write'
+      packages: 'write'
+      id-token: 'write'
+      issues: 'write'
+    outputs:
+      RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+        with:
+          ref: '${{ github.event.inputs.ref || github.sha }}'
+          fetch-depth: 0
+
+      - name: 'Set booleans for simplified logic'
+        env:
+          CREATE_NIGHTLY_RELEASE: '${{ github.event.inputs.create_nightly_release }}'
+          CREATE_PREVIEW_RELEASE: '${{ github.event.inputs.create_preview_release }}'
+          DRY_RUN_INPUT: '${{ github.event.inputs.dry_run }}'
+        id: 'vars'
+        run: |-
+          is_nightly="false"
+          if [[ "${CREATE_NIGHTLY_RELEASE}" == "true" ]]; then
+            is_nightly="true"
+          fi
+          echo "is_nightly=${is_nightly}" >> "${GITHUB_OUTPUT}"
+
+          is_preview="false"
+          if [[ "${CREATE_PREVIEW_RELEASE}" == "true" ]]; then
+            is_preview="true"
+          fi
+          echo "is_preview=${is_preview}" >> "${GITHUB_OUTPUT}"
+
+          is_dry_run="false"
+          if [[ "${DRY_RUN_INPUT}" == "true" ]]; then
+            is_dry_run="true"
+          fi
+          echo "is_dry_run=${is_dry_run}" >> "${GITHUB_OUTPUT}"
+
+      - name: 'Setup Node.js'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+
+      - name: 'Install Dependencies'
+        run: |-
+          npm ci
+
+      - name: 'Get the version'
+        id: 'version'
+        run: |
+          VERSION_ARGS=()
+          if [[ "${IS_NIGHTLY}" == "true" ]]; then
+            VERSION_ARGS+=(--type=nightly)
+          elif [[ "${IS_PREVIEW}" == "true" ]]; then
+            VERSION_ARGS+=(--type=preview)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--preview_version_override=${MANUAL_VERSION}")
+            fi
+          else
+            VERSION_ARGS+=(--type=stable)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--stable_version_override=${MANUAL_VERSION}")
+            fi
+          fi
+
+          VERSION_JSON=$(node packages/sdk-typescript/scripts/get-release-version.js "${VERSION_ARGS[@]}")
+          echo "RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .releaseTag)" >> "$GITHUB_OUTPUT"
+          echo "RELEASE_VERSION=$(echo "$VERSION_JSON" | jq -r .releaseVersion)" >> "$GITHUB_OUTPUT"
+          echo "NPM_TAG=$(echo "$VERSION_JSON" | jq -r .npmTag)" >> "$GITHUB_OUTPUT"
+
+          echo "PREVIOUS_RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .previousReleaseTag)" >> "$GITHUB_OUTPUT"
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          IS_NIGHTLY: '${{ steps.vars.outputs.is_nightly }}'
+          IS_PREVIEW: '${{ steps.vars.outputs.is_preview }}'
+          MANUAL_VERSION: '${{ inputs.version }}'
+
+      - name: 'Run Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        working-directory: 'packages/sdk-typescript'
+        run: |
+          npm run test:ci
+        env:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          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]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: 'Create and switch to a release branch'
+        id: 'release_branch'
+        env:
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
+          BRANCH_NAME="release/sdk-typescript/${RELEASE_TAG}"
+          git switch -c "${BRANCH_NAME}"
+          echo "BRANCH_NAME=${BRANCH_NAME}" >> "${GITHUB_OUTPUT}"
+
+      - name: 'Update package version'
+        working-directory: 'packages/sdk-typescript'
+        env:
+          RELEASE_VERSION: '${{ steps.version.outputs.RELEASE_VERSION }}'
+        run: |-
+          npm version "${RELEASE_VERSION}" --no-git-tag-version --allow-same-version
+
+      - name: 'Commit and Conditionally Push package version'
+        env:
+          BRANCH_NAME: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          IS_DRY_RUN: '${{ steps.vars.outputs.is_dry_run }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
+          git add packages/sdk-typescript/package.json
+          if git diff --staged --quiet; then
+            echo "No version changes to commit"
+          else
+            git commit -m "chore(release): sdk-typescript ${RELEASE_TAG}"
+          fi
+          if [[ "${IS_DRY_RUN}" == "false" ]]; then
+            echo "Pushing release branch to remote..."
+            git push --set-upstream origin "${BRANCH_NAME}" --follow-tags
+          else
+            echo "Dry run enabled. Skipping push."
+          fi
+
+      - name: 'Build SDK'
+        working-directory: 'packages/sdk-typescript'
+        run: |-
+          npm run build
+
+      - name: 'Configure npm for publishing'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          registry-url: 'https://registry.npmjs.org'
+          scope: '@qwen-code'
+
+      - 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' || '' }}
+        env:
+          NODE_AUTH_TOKEN: '${{ secrets.NPM_TOKEN }}'
+
+      - name: 'Create GitHub Release and Tag'
+        if: |-
+          ${{ steps.vars.outputs.is_dry_run == 'false' }}
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_BRANCH: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+          PREVIOUS_RELEASE_TAG: '${{ steps.version.outputs.PREVIOUS_RELEASE_TAG }}'
+        run: |-
+          gh release create "sdk-typescript-${RELEASE_TAG}" \
+            --target "$RELEASE_BRANCH" \
+            --title "SDK TypeScript Release ${RELEASE_TAG}" \
+            --notes-start-tag "sdk-typescript-${PREVIOUS_RELEASE_TAG}" \
+            --generate-notes
+
+      - name: 'Create Issue on Failure'
+        if: |-
+          ${{ failure() }}
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_TAG: "${{ steps.version.outputs.RELEASE_TAG || 'N/A' }}"
+          DETAILS_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+        run: |-
+          gh issue create \
+            --title "SDK Release Failed for ${RELEASE_TAG} on $(date +'%Y-%m-%d')" \
+            --body "The SDK release workflow failed. See the full run for details: ${DETAILS_URL}"

.vscode/launch.json

@@ -79,7 +79,6 @@
         "--",
         "-p",
         "${input:prompt}",
-        "-y",
         "--output-format",
         "stream-json"
       ],

docs/cli/commands.md

@@ -11,31 +11,8 @@ Slash commands provide meta-level control over the CLI itself.
 - **`/bug`**
   - **Description:** File an issue about Qwen Code. By default, the issue is filed within the GitHub repository for Qwen Code. The string you enter after `/bug` will become the headline for the bug being filed. The default `/bug` behavior can be modified using the `advanced.bugCommand` setting in your `.qwen/settings.json` files.
 
-- **`/chat`**
-  - **Description:** Save and resume conversation history for branching conversation state interactively, or resuming a previous state from a later session.
-  - **Sub-commands:**
-    - **`save`**
-      - **Description:** Saves the current conversation history. You must add a `<tag>` for identifying the conversation state.
-      - **Usage:** `/chat save <tag>`
-      - **Details on Checkpoint Location:** The default locations for saved chat checkpoints are:
-        - Linux/macOS: `~/.qwen/tmp/<project_hash>/`
-        - Windows: `C:\Users\<YourUsername>\.qwen\tmp\<project_hash>\`
-        - When you run `/chat list`, the CLI only scans these specific directories to find available checkpoints.
-        - **Note:** These checkpoints are for manually saving and resuming conversation states. For automatic checkpoints created before file modifications, see the [Checkpointing documentation](../checkpointing.md).
-    - **`resume`**
-      - **Description:** Resumes a conversation from a previous save.
-      - **Usage:** `/chat resume <tag>`
-    - **`list`**
-      - **Description:** Lists available tags for chat state resumption.
-    - **`delete`**
-      - **Description:** Deletes a saved conversation checkpoint.
-      - **Usage:** `/chat delete <tag>`
-    - **`share`**
-      - **Description** Writes the current conversation to a provided Markdown or JSON file.
-      - **Usage** `/chat share file.md` or `/chat share file.json`. If no filename is provided, then the CLI will generate one.
-
-- **`/clear`**
-  - **Description:** Clear the terminal screen, including the visible session history and scrollback within the CLI. The underlying session data (for history recall) might be preserved depending on the exact implementation, but the visual display is cleared.
+- **`/clear`** (aliases: `reset`, `new`)
+  - **Description:** Clear conversation history and free up context by starting a fresh session. Also clears the terminal output and scrollback within the CLI.
   - **Keyboard shortcut:** Press **Ctrl+L** at any time to perform a clear action.
 
 - **`/summary`**
@@ -168,16 +145,6 @@ Slash commands provide meta-level control over the CLI itself.
     - **`nodesc`** or **`nodescriptions`**:
       - **Description:** Hide tool descriptions, showing only the tool names.
 
-- **`/quit-confirm`**
-  - **Description:** Show a confirmation dialog before exiting Qwen Code, allowing you to choose how to handle your current session.
-  - **Usage:** `/quit-confirm`
-  - **Features:**
-    - **Quit immediately:** Exit without saving anything (equivalent to `/quit`)
-    - **Generate summary and quit:** Create a project summary using `/summary` before exiting
-    - **Save conversation and quit:** Save the current conversation with an auto-generated tag before exiting
-  - **Keyboard shortcut:** Press **Ctrl+C** twice to trigger the quit confirmation dialog
-  - **Note:** This command is automatically triggered when you press Ctrl+C once, providing a safety mechanism to prevent accidental exits.
-
 - **`/quit`** (or **`/exit`**)
   - **Description:** Exit Qwen Code immediately without any confirmation dialog.
 

docs/cli/configuration-v1.md

@@ -671,4 +671,4 @@ Note: When usage statistics are enabled, events are sent to an Alibaba Cloud RUM
   - **Category:** UI
   - **Requires Restart:** No
   - **Example:** `"enableWelcomeBack": false`
-  - **Details:** When enabled, Qwen Code will automatically detect if you're returning to a project with a previously generated project summary (`.qwen/PROJECT_SUMMARY.md`) and show a dialog allowing you to continue your previous conversation or start fresh. This feature integrates with the `/chat summary` command and quit confirmation dialog. See the [Welcome Back documentation](./welcome-back.md) for more details.
+  - **Details:** When enabled, Qwen Code will automatically detect if you're returning to a project with a previously generated project summary (`.qwen/PROJECT_SUMMARY.md`) and show a dialog allowing you to continue your previous conversation or start fresh. This feature integrates with the `/summary` command. See the [Welcome Back documentation](./welcome-back.md) for more details.

docs/cli/configuration.md

@@ -548,6 +548,12 @@ Arguments passed directly when running the CLI can override other configurations
   - The prompt is processed within the interactive session, not before it.
   - Cannot be used when piping input from stdin.
   - Example: `qwen -i "explain this code"`
+- **`--continue`**:
+  - Resume the most recent session for the current project (current working directory).
+  - Works in interactive and headless modes (e.g., `qwen --continue -p "Keep going"`).
+- **`--resume [sessionId]`**:
+  - Resume a specific session for the current project. When called without an ID, an interactive picker lists only this project's sessions with prompt preview, timestamps, message count, and optional git branch.
+  - If an ID is provided and not found for this project, the CLI exits with an error.
 - **`--output-format <format>`** (**`-o <format>`**):
   - **Description:** Specifies the format of the CLI output for non-interactive mode.
   - **Values:**

docs/features/headless.md

@@ -38,6 +38,7 @@ The headless mode provides a headless interface to Qwen Code that:
 - Supports file redirection and piping
 - Enables automation and scripting workflows
 - Provides consistent exit codes for error handling
+- Can resume previous sessions scoped to the current project for multi-step automation
 
 ## Basic Usage
 
@@ -65,6 +66,23 @@ Read from files and process with Qwen Code:
 cat README.md | qwen --prompt "Summarize this documentation"
 ```
 
+### Resume Previous Sessions (Headless)
+
+Reuse conversation context from the current project in headless scripts:
+
+```bash
+# Continue the most recent session for this project and run a new prompt
+qwen --continue -p "Run the tests again and summarize failures"
+
+# Resume a specific session ID directly (no UI)
+qwen --resume 123e4567-e89b-12d3-a456-426614174000 -p "Apply the follow-up refactor"
+```
+
+Notes:
+
+- Session data is project-scoped JSONL under `~/.qwen/projects/<sanitized-cwd>/chats`.
+- Restores conversation history, tool outputs, and chat-compression checkpoints before sending the new prompt.
+
 ## Output Formats
 
 Qwen Code supports multiple output formats for different use cases:
@@ -196,17 +214,19 @@ qwen -p "Write code" --output-format stream-json --include-partial-messages | jq
 
 Key command-line options for headless usage:
 
-| Option                       | Description                                     | Example                                                                  |
-| ---------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------ |
-| `--prompt`, `-p`             | Run in headless mode                            | `qwen -p "query"`                                                        |
-| `--output-format`, `-o`      | Specify output format (text, json, stream-json) | `qwen -p "query" --output-format json`                                   |
-| `--input-format`             | Specify input format (text, stream-json)        | `qwen --input-format text --output-format stream-json`                   |
-| `--include-partial-messages` | Include partial messages in stream-json output  | `qwen -p "query" --output-format stream-json --include-partial-messages` |
-| `--debug`, `-d`              | Enable debug mode                               | `qwen -p "query" --debug`                                                |
-| `--all-files`, `-a`          | Include all files in context                    | `qwen -p "query" --all-files`                                            |
-| `--include-directories`      | Include additional directories                  | `qwen -p "query" --include-directories src,docs`                         |
-| `--yolo`, `-y`               | Auto-approve all actions                        | `qwen -p "query" --yolo`                                                 |
-| `--approval-mode`            | Set approval mode                               | `qwen -p "query" --approval-mode auto_edit`                              |
+| Option                       | Description                                         | Example                                                                  |
+| ---------------------------- | --------------------------------------------------- | ------------------------------------------------------------------------ |
+| `--prompt`, `-p`             | Run in headless mode                                | `qwen -p "query"`                                                        |
+| `--output-format`, `-o`      | Specify output format (text, json, stream-json)     | `qwen -p "query" --output-format json`                                   |
+| `--input-format`             | Specify input format (text, stream-json)            | `qwen --input-format text --output-format stream-json`                   |
+| `--include-partial-messages` | Include partial messages in stream-json output      | `qwen -p "query" --output-format stream-json --include-partial-messages` |
+| `--debug`, `-d`              | Enable debug mode                                   | `qwen -p "query" --debug`                                                |
+| `--all-files`, `-a`          | Include all files in context                        | `qwen -p "query" --all-files`                                            |
+| `--include-directories`      | Include additional directories                      | `qwen -p "query" --include-directories src,docs`                         |
+| `--yolo`, `-y`               | Auto-approve all actions                            | `qwen -p "query" --yolo`                                                 |
+| `--approval-mode`            | Set approval mode                                   | `qwen -p "query" --approval-mode auto_edit`                              |
+| `--continue`                 | Resume the most recent session for this project     | `qwen --continue -p "Pick up where we left off"`                         |
+| `--resume [sessionId]`       | Resume a specific session (or choose interactively) | `qwen --resume 123e... -p "Finish the refactor"`                         |
 
 For complete details on all available configuration options, settings files, and environment variables, see the [Configuration Guide](./cli/configuration.md).
 

docs/features/welcome-back.md

@@ -75,20 +75,12 @@ Add to your `.qwen/settings.json`:
 
 ### Project Summary Generation
 
-The Welcome Back feature works seamlessly with the `/chat summary` command:
+The Welcome Back feature works seamlessly with the `/summary` command:
 
-1. **Generate Summary:** Use `/chat summary` to create a project summary
+1. **Generate Summary:** Use `/summary` to create a project summary
 2. **Automatic Detection:** Next time you start Qwen Code in this project, Welcome Back will detect the summary
 3. **Resume Work:** Choose to continue and the summary will be loaded as context
 
-### Quit Confirmation
-
-When exiting with `/quit-confirm` and choosing "Generate summary and quit":
-
-1. A project summary is automatically created
-2. Next session will trigger the Welcome Back dialog
-3. You can seamlessly continue your work
-
 ## File Structure
 
 The Welcome Back feature creates and uses:

docs/index.md

@@ -72,7 +72,7 @@ Create or edit `.qwen/settings.json` in your home directory:
 #### Session Commands
 
 - **`/compress`** - Compress conversation history to continue within token limits
-- **`/clear`** - Clear all conversation history and start fresh
+- **`/clear`** (aliases: `/reset`, `/new`) - Clear conversation history, start a fresh session, and free up context
 - **`/stats`** - Check current token usage and limits
 
 > 📝 **Note**: Session token limit applies to a single conversation, not cumulative API calls.
@@ -332,7 +332,7 @@ qwen
 ### Session Commands
 
 - `/help` - Display available commands
-- `/clear` - Clear conversation history
+- `/clear` (aliases: `/reset`, `/new`) - Clear conversation history and start a fresh session
 - `/compress` - Compress history to save tokens
 - `/stats` - Show current session information
 - `/exit` or `/quit` - Exit Qwen Code

eslint.config.js

@@ -22,6 +22,7 @@ export default tseslint.config(
       'bundle/**',
       'package/bundle/**',
       '.integration-tests/**',
+      'packages/**/.integration-test/**',
       'dist/**',
     ],
   },
@@ -150,7 +151,7 @@ export default tseslint.config(
     },
   },
   {
-    files: ['packages/*/src/**/*.test.{ts,tsx}'],
+    files: ['packages/*/src/**/*.test.{ts,tsx}', 'packages/**/test/**/*.test.{ts,tsx}'],
     plugins: {
       vitest,
     },
@@ -158,11 +159,19 @@ export default tseslint.config(
       ...vitest.configs.recommended.rules,
       'vitest/expect-expect': 'off',
       'vitest/no-commented-out-tests': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+        },
+      ],
     },
   },
   // extra settings for scripts that we run directly with node
   {
-    files: ['./scripts/**/*.js', 'esbuild.config.js'],
+    files: ['./scripts/**/*.js', 'esbuild.config.js', 'packages/*/scripts/**/*.js'],
     languageOptions: {
       globals: {
         ...globals.node,
@@ -229,7 +238,7 @@ export default tseslint.config(
   prettierConfig,
   // extra settings for scripts that we run directly with node
   {
-    files: ['./integration-tests/**/*.js'],
+    files: ['./integration-tests/**/*.{js,ts,tsx}'],
     languageOptions: {
       globals: {
         ...globals.node,

integration-tests/acp-integration.test.ts

@@ -0,0 +1,590 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { setTimeout as delay } from 'node:timers/promises';
+import { describe, expect, it } from 'vitest';
+import { TestRig } from './test-helper.js';
+
+const REQUEST_TIMEOUT_MS = 60_000;
+const INITIAL_PROMPT = 'Create a quick note (smoke test).';
+const RESUME_PROMPT = 'Continue the note after reload.';
+const LIST_SIZE = 5;
+const IS_SANDBOX =
+  process.env['GEMINI_SANDBOX'] &&
+  process.env['GEMINI_SANDBOX']!.toLowerCase() !== 'false';
+
+type PendingRequest = {
+  resolve: (value: unknown) => void;
+  reject: (reason: Error) => void;
+  timeout: NodeJS.Timeout;
+};
+
+type SessionUpdateNotification = {
+  sessionId?: string;
+  update?: {
+    sessionUpdate?: string;
+    availableCommands?: Array<{
+      name: string;
+      description: string;
+      input?: { hint: string } | null;
+    }>;
+    content?: {
+      type: string;
+      text?: string;
+    };
+    modeId?: string;
+  };
+};
+
+type PermissionRequest = {
+  id: number;
+  sessionId?: string;
+  toolCall?: {
+    toolCallId: string;
+    title: string;
+    kind: string;
+    status: string;
+    content?: Array<{
+      type: string;
+      text?: string;
+      path?: string;
+      oldText?: string;
+      newText?: string;
+    }>;
+  };
+  options?: Array<{
+    optionId: string;
+    name: string;
+    kind: string;
+  }>;
+};
+
+type PermissionHandler = (
+  request: PermissionRequest,
+) => { optionId: string } | { outcome: 'cancelled' };
+
+/**
+ * Sets up an ACP test environment with all necessary utilities.
+ */
+function setupAcpTest(
+  rig: TestRig,
+  options?: { permissionHandler?: PermissionHandler },
+) {
+  const pending = new Map<number, PendingRequest>();
+  let nextRequestId = 1;
+  const sessionUpdates: SessionUpdateNotification[] = [];
+  const permissionRequests: PermissionRequest[] = [];
+  const stderr: string[] = [];
+
+  // Default permission handler: auto-approve all
+  const permissionHandler =
+    options?.permissionHandler ?? (() => ({ optionId: 'proceed_once' }));
+
+  const agent = spawn('node', [rig.bundlePath, '--experimental-acp'], {
+    cwd: rig.testDir!,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  agent.stderr?.on('data', (chunk) => {
+    stderr.push(chunk.toString());
+  });
+
+  const rl = createInterface({ input: agent.stdout });
+
+  const send = (json: unknown) => {
+    agent.stdin.write(`${JSON.stringify(json)}\n`);
+  };
+
+  const sendResponse = (id: number, result: unknown) => {
+    send({ jsonrpc: '2.0', id, result });
+  };
+
+  const sendRequest = (method: string, params?: unknown) =>
+    new Promise<unknown>((resolve, reject) => {
+      const id = nextRequestId++;
+      const timeout = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Request ${id} (${method}) timed out`));
+      }, REQUEST_TIMEOUT_MS);
+      pending.set(id, { resolve, reject, timeout });
+      send({ jsonrpc: '2.0', id, method, params });
+    });
+
+  const handleResponse = (msg: {
+    id: number;
+    result?: unknown;
+    error?: { message?: string };
+  }) => {
+    const waiter = pending.get(msg.id);
+    if (!waiter) {
+      return;
+    }
+    clearTimeout(waiter.timeout);
+    pending.delete(msg.id);
+    if (msg.error) {
+      waiter.reject(new Error(msg.error.message ?? 'Unknown error'));
+    } else {
+      waiter.resolve(msg.result);
+    }
+  };
+
+  const handleMessage = (msg: {
+    id?: number;
+    method?: string;
+    params?: SessionUpdateNotification & {
+      path?: string;
+      content?: string;
+      sessionId?: string;
+      toolCall?: PermissionRequest['toolCall'];
+      options?: PermissionRequest['options'];
+    };
+    result?: unknown;
+    error?: { message?: string };
+  }) => {
+    if (typeof msg.id !== 'undefined' && ('result' in msg || 'error' in msg)) {
+      handleResponse(
+        msg as {
+          id: number;
+          result?: unknown;
+          error?: { message?: string };
+        },
+      );
+      return;
+    }
+
+    if (msg.method === 'session/update') {
+      sessionUpdates.push({
+        sessionId: msg.params?.sessionId,
+        update: msg.params?.update,
+      });
+      return;
+    }
+
+    if (
+      msg.method === 'session/request_permission' &&
+      typeof msg.id === 'number'
+    ) {
+      // Track permission request
+      const permRequest: PermissionRequest = {
+        id: msg.id,
+        sessionId: msg.params?.sessionId,
+        toolCall: msg.params?.toolCall,
+        options: msg.params?.options,
+      };
+      permissionRequests.push(permRequest);
+
+      // Use custom handler or default
+      const response = permissionHandler(permRequest);
+      if ('outcome' in response) {
+        sendResponse(msg.id, { outcome: response });
+      } else {
+        sendResponse(msg.id, {
+          outcome: { optionId: response.optionId, outcome: 'selected' },
+        });
+      }
+      return;
+    }
+
+    if (msg.method === 'fs/read_text_file' && typeof msg.id === 'number') {
+      try {
+        const content = readFileSync(msg.params?.path ?? '', 'utf8');
+        sendResponse(msg.id, { content });
+      } catch (e) {
+        sendResponse(msg.id, { content: `ERROR: ${(e as Error).message}` });
+      }
+      return;
+    }
+
+    if (msg.method === 'fs/write_text_file' && typeof msg.id === 'number') {
+      try {
+        writeFileSync(
+          msg.params?.path ?? '',
+          msg.params?.content ?? '',
+          'utf8',
+        );
+        sendResponse(msg.id, null);
+      } catch (e) {
+        sendResponse(msg.id, { message: (e as Error).message });
+      }
+    }
+  };
+
+  rl.on('line', (line) => {
+    if (!line.trim()) return;
+    try {
+      const msg = JSON.parse(line);
+      handleMessage(msg);
+    } catch {
+      // Ignore non-JSON output from the agent.
+    }
+  });
+
+  const waitForExit = () =>
+    new Promise<void>((resolve) => {
+      if (agent.exitCode !== null || agent.signalCode) {
+        resolve();
+        return;
+      }
+      agent.once('exit', () => resolve());
+    });
+
+  const cleanup = async () => {
+    rl.close();
+    agent.kill();
+    pending.forEach(({ timeout }) => clearTimeout(timeout));
+    pending.clear();
+    await waitForExit();
+  };
+
+  return {
+    sendRequest,
+    sendResponse,
+    cleanup,
+    stderr,
+    sessionUpdates,
+    permissionRequests,
+  };
+}
+
+(IS_SANDBOX ? describe.skip : describe)('acp integration', () => {
+  it('creates, lists, loads, and resumes a session', async () => {
+    const rig = new TestRig();
+    rig.setup('acp load session');
+
+    const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
+
+    try {
+      const initResult = await sendRequest('initialize', {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+        },
+      });
+      expect(initResult).toBeDefined();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      expect((initResult as any).agentInfo.version).toBeDefined();
+
+      await sendRequest('authenticate', { methodId: 'openai' });
+
+      const newSession = (await sendRequest('session/new', {
+        cwd: rig.testDir!,
+        mcpServers: [],
+      })) as { sessionId: string };
+      expect(newSession.sessionId).toBeTruthy();
+
+      const promptResult = await sendRequest('session/prompt', {
+        sessionId: newSession.sessionId,
+        prompt: [{ type: 'text', text: INITIAL_PROMPT }],
+      });
+      expect(promptResult).toBeDefined();
+
+      await delay(500);
+
+      const listResult = (await sendRequest('session/list', {
+        cwd: rig.testDir!,
+        size: LIST_SIZE,
+      })) as { items?: Array<{ sessionId: string }> };
+
+      expect(Array.isArray(listResult.items)).toBe(true);
+      expect(listResult.items?.length ?? 0).toBeGreaterThan(0);
+
+      const sessionToLoad = listResult.items![0].sessionId;
+      await sendRequest('session/load', {
+        cwd: rig.testDir!,
+        sessionId: sessionToLoad,
+        mcpServers: [],
+      });
+
+      const resumeResult = await sendRequest('session/prompt', {
+        sessionId: sessionToLoad,
+        prompt: [{ type: 'text', text: RESUME_PROMPT }],
+      });
+      expect(resumeResult).toBeDefined();
+
+      const sessionsWithUpdates = sessionUpdates
+        .map((update) => update.sessionId)
+        .filter(Boolean);
+      expect(sessionsWithUpdates).toContain(sessionToLoad);
+    } catch (e) {
+      if (stderr.length) {
+        console.error('Agent stderr:', stderr.join(''));
+      }
+      throw e;
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('returns modes on initialize and allows setting approval mode', async () => {
+    const rig = new TestRig();
+    rig.setup('acp approval mode');
+
+    const { sendRequest, cleanup, stderr } = setupAcpTest(rig);
+
+    try {
+      // Test 1: Initialize and verify modes are returned
+      const initResult = (await sendRequest('initialize', {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+        },
+      })) as {
+        protocolVersion: number;
+        modes: {
+          currentModeId: string;
+          availableModes: Array<{
+            id: string;
+            name: string;
+            description: string;
+          }>;
+        };
+      };
+
+      expect(initResult).toBeDefined();
+      expect(initResult.protocolVersion).toBe(1);
+
+      // Verify modes data is present
+      expect(initResult.modes).toBeDefined();
+      expect(initResult.modes.currentModeId).toBeDefined();
+      expect(Array.isArray(initResult.modes.availableModes)).toBe(true);
+      expect(initResult.modes.availableModes.length).toBeGreaterThan(0);
+
+      // Verify available modes have expected structure
+      const modeIds = initResult.modes.availableModes.map((m) => m.id);
+      expect(modeIds).toContain('default');
+      expect(modeIds).toContain('yolo');
+      expect(modeIds).toContain('auto-edit');
+      expect(modeIds).toContain('plan');
+
+      // Verify each mode has required fields
+      for (const mode of initResult.modes.availableModes) {
+        expect(mode.id).toBeTruthy();
+        expect(mode.name).toBeTruthy();
+        expect(mode.description).toBeTruthy();
+      }
+
+      // Test 2: Authenticate
+      await sendRequest('authenticate', { methodId: 'openai' });
+
+      // Test 3: Create a new session
+      const newSession = (await sendRequest('session/new', {
+        cwd: rig.testDir!,
+        mcpServers: [],
+      })) as { sessionId: string };
+      expect(newSession.sessionId).toBeTruthy();
+
+      // Test 4: Set approval mode to 'yolo'
+      const setModeResult = (await sendRequest('session/set_mode', {
+        sessionId: newSession.sessionId,
+        modeId: 'yolo',
+      })) as { modeId: string };
+      expect(setModeResult).toBeDefined();
+      expect(setModeResult.modeId).toBe('yolo');
+
+      // Test 5: Set approval mode to 'auto-edit'
+      const setModeResult2 = (await sendRequest('session/set_mode', {
+        sessionId: newSession.sessionId,
+        modeId: 'auto-edit',
+      })) as { modeId: string };
+      expect(setModeResult2).toBeDefined();
+      expect(setModeResult2.modeId).toBe('auto-edit');
+
+      // Test 6: Set approval mode back to 'default'
+      const setModeResult3 = (await sendRequest('session/set_mode', {
+        sessionId: newSession.sessionId,
+        modeId: 'default',
+      })) as { modeId: string };
+      expect(setModeResult3).toBeDefined();
+      expect(setModeResult3.modeId).toBe('default');
+    } catch (e) {
+      if (stderr.length) {
+        console.error('Agent stderr:', stderr.join(''));
+      }
+      throw e;
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('receives available_commands_update with slash commands after session creation', async () => {
+    const rig = new TestRig();
+    rig.setup('acp slash commands');
+
+    const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
+
+    try {
+      // Initialize
+      await sendRequest('initialize', {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+        },
+      });
+
+      await sendRequest('authenticate', { methodId: 'openai' });
+
+      // Create a new session
+      const newSession = (await sendRequest('session/new', {
+        cwd: rig.testDir!,
+        mcpServers: [],
+      })) as { sessionId: string };
+      expect(newSession.sessionId).toBeTruthy();
+
+      // Wait for available_commands_update to be received
+      await delay(1000);
+
+      // Verify available_commands_update is received
+      const commandsUpdate = sessionUpdates.find(
+        (update) =>
+          update.update?.sessionUpdate === 'available_commands_update',
+      );
+
+      expect(commandsUpdate).toBeDefined();
+      expect(commandsUpdate?.update?.availableCommands).toBeDefined();
+      expect(Array.isArray(commandsUpdate?.update?.availableCommands)).toBe(
+        true,
+      );
+
+      // Verify that the 'init' command is present (the only allowed built-in command for ACP)
+      const initCommand = commandsUpdate?.update?.availableCommands?.find(
+        (cmd) => cmd.name === 'init',
+      );
+      expect(initCommand).toBeDefined();
+      expect(initCommand?.description).toBeTruthy();
+
+      // Note: We don't test /init execution here because it triggers a complex
+      // multi-step process (listing files, reading up to 10 files, generating QWEN.md)
+      // that can take 30-60+ seconds, exceeding the request timeout.
+      // The slash command execution path is tested via simpler prompts in other tests.
+    } catch (e) {
+      if (stderr.length) {
+        console.error('Agent stderr:', stderr.join(''));
+      }
+      throw e;
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('handles exit plan mode with permission request and mode update notification', async () => {
+    const rig = new TestRig();
+    rig.setup('acp exit plan mode');
+
+    // Track which permission requests we've seen
+    const planModeRequests: PermissionRequest[] = [];
+
+    const { sendRequest, cleanup, stderr, sessionUpdates, permissionRequests } =
+      setupAcpTest(rig, {
+        permissionHandler: (request) => {
+          // Track all permission requests for later verification
+          // Auto-approve exit plan mode requests with "proceed_always" to trigger auto-edit mode
+          if (request.toolCall?.kind === 'switch_mode') {
+            planModeRequests.push(request);
+            // Return proceed_always to switch to auto-edit mode
+            return { optionId: 'proceed_always' };
+          }
+          // Auto-approve all other requests
+          return { optionId: 'proceed_once' };
+        },
+      });
+
+    try {
+      // Initialize
+      await sendRequest('initialize', {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+        },
+      });
+
+      await sendRequest('authenticate', { methodId: 'openai' });
+
+      // Create a new session
+      const newSession = (await sendRequest('session/new', {
+        cwd: rig.testDir!,
+        mcpServers: [],
+      })) as { sessionId: string };
+      expect(newSession.sessionId).toBeTruthy();
+
+      // Set mode to 'plan' to enable plan mode
+      const setModeResult = (await sendRequest('session/set_mode', {
+        sessionId: newSession.sessionId,
+        modeId: 'plan',
+      })) as { modeId: string };
+      expect(setModeResult.modeId).toBe('plan');
+
+      // Send a prompt that should trigger the LLM to call exit_plan_mode
+      // The prompt is designed to trigger planning behavior
+      const promptResult = await sendRequest('session/prompt', {
+        sessionId: newSession.sessionId,
+        prompt: [
+          {
+            type: 'text',
+            text: 'Create a simple hello world function in Python. Make a brief plan and when ready, use the exit_plan_mode tool to present it for approval.',
+          },
+        ],
+      });
+      expect(promptResult).toBeDefined();
+
+      // Give time for all notifications to be processed
+      await delay(1000);
+
+      // Verify: If exit_plan_mode was called, we should have received:
+      // 1. A permission request with kind: "switch_mode"
+      // 2. A current_mode_update notification after approval
+
+      // Check for switch_mode permission requests
+      const switchModeRequests = permissionRequests.filter(
+        (req) => req.toolCall?.kind === 'switch_mode',
+      );
+
+      // Check for current_mode_update notifications
+      const modeUpdateNotifications = sessionUpdates.filter(
+        (update) => update.update?.sessionUpdate === 'current_mode_update',
+      );
+
+      // If the LLM called exit_plan_mode, verify the flow
+      if (switchModeRequests.length > 0) {
+        // Verify permission request structure
+        const permReq = switchModeRequests[0];
+        expect(permReq.toolCall).toBeDefined();
+        expect(permReq.toolCall?.kind).toBe('switch_mode');
+        expect(permReq.toolCall?.status).toBe('pending');
+        expect(permReq.options).toBeDefined();
+        expect(Array.isArray(permReq.options)).toBe(true);
+
+        // Verify options include appropriate choices
+        const optionKinds = permReq.options?.map((opt) => opt.kind) ?? [];
+        expect(optionKinds).toContain('allow_once');
+        expect(optionKinds).toContain('allow_always');
+
+        // After approval, should have received current_mode_update
+        expect(modeUpdateNotifications.length).toBeGreaterThan(0);
+
+        // Verify mode update structure
+        const modeUpdate = modeUpdateNotifications[0];
+        expect(modeUpdate.sessionId).toBe(newSession.sessionId);
+        expect(modeUpdate.update?.modeId).toBeDefined();
+        // Mode should be auto-edit since we approved with proceed_always
+        expect(modeUpdate.update?.modeId).toBe('auto-edit');
+      }
+
+      // Note: If the LLM didn't call exit_plan_mode, that's acceptable
+      // since LLM behavior is non-deterministic. The test setup and structure
+      // is verified regardless.
+    } catch (e) {
+      if (stderr.length) {
+        console.error('Agent stderr:', stderr.join(''));
+      }
+      throw e;
+    } finally {
+      await cleanup();
+    }
+  });
+});

integration-tests/ctrl-c-exit.test.ts

@@ -6,124 +6,71 @@
 
 import { describe, it, expect } from 'vitest';
 import { TestRig } from './test-helper.js';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
 
 describe('Ctrl+C exit', () => {
   // (#9782) Temporarily disabling on windows because it is failing on main and every
   // PR, which is potentially hiding other failures
-  it.skipIf(process.platform === 'win32')(
-    'should exit gracefully on second Ctrl+C',
-    async () => {
-      const rig = new TestRig();
-      await rig.setup('should exit gracefully on second Ctrl+C');
+  it.skip('should exit gracefully on second Ctrl+C', async () => {
+    const rig = new TestRig();
+    await rig.setup('should exit gracefully on second Ctrl+C');
 
-      const { ptyProcess, promise } = rig.runInteractive();
+    const { ptyProcess, promise } = rig.runInteractive();
 
-      let output = '';
-      ptyProcess.onData((data) => {
-        output += data;
-      });
+    let output = '';
+    ptyProcess.onData((data) => {
+      output += data;
+    });
 
-      // Wait for the app to be ready by looking for the initial prompt indicator
-      await rig.poll(() => output.includes('▶'), 5000, 100);
+    const isReady = await rig.waitForText('Type your message', 15000);
+    expect(isReady, 'CLI did not start up in interactive mode correctly').toBe(
+      true,
+    );
 
-      // Send first Ctrl+C
-      ptyProcess.write(String.fromCharCode(3));
+    // Send first Ctrl+C
+    ptyProcess.write(String.fromCharCode(3));
 
-      // Wait for the exit prompt
-      await rig.poll(
-        () => output.includes('Press Ctrl+C again to exit'),
-        1500,
-        50,
-      );
+    // Wait for the exit prompt
+    const showedExitPrompt = await rig.poll(
+      () => output.includes('Press Ctrl+C again to exit'),
+      1500,
+      50,
+    );
+    expect(showedExitPrompt, `Exit prompt not shown. Output: ${output}`).toBe(
+      true,
+    );
 
-      // Send second Ctrl+C
-      ptyProcess.write(String.fromCharCode(3));
+    // Send second Ctrl+C
+    ptyProcess.write(String.fromCharCode(3));
 
-      const result = await promise;
+    // Wait for process exit with timeout to fail fast
+    const EXIT_TIMEOUT = 5000;
+    const result = await Promise.race([
+      promise,
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () =>
+            reject(
+              new Error(
+                `Process did not exit within ${EXIT_TIMEOUT}ms. Output: ${output}`,
+              ),
+            ),
+          EXIT_TIMEOUT,
+        ),
+      ),
+    ]);
 
-      // Expect a graceful exit (code 0)
-      expect(
-        result.exitCode,
-        `Process exited with code ${result.exitCode}. Output: ${result.output}`,
-      ).toBe(0);
+    // Expect a graceful exit (code 0)
+    expect(
+      result.exitCode,
+      `Process exited with code ${result.exitCode}. Output: ${result.output}`,
+    ).toBe(0);
 
-      // Check that the quitting message is displayed
-      const quittingMessage = 'Agent powering down. Goodbye!';
-      // The regex below is intentionally matching the ESC control character (\x1b)
-      // to strip ANSI color codes from the terminal output.
-      // eslint-disable-next-line no-control-regex
-      const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
-      expect(cleanOutput).toContain(quittingMessage);
-    },
-  );
-
-  it.skipIf(process.platform === 'win32')(
-    'should exit gracefully on second Ctrl+C when calling a tool',
-    async () => {
-      const rig = new TestRig();
-      await rig.setup(
-        'should exit gracefully on second Ctrl+C when calling a tool',
-      );
-
-      const childProcessFile = 'child_process_file.txt';
-      rig.createFile(
-        'wait.js',
-        `setTimeout(() => require('fs').writeFileSync('${childProcessFile}', 'done'), 5000)`,
-      );
-
-      const { ptyProcess, promise } = rig.runInteractive();
-
-      let output = '';
-      ptyProcess.onData((data) => {
-        output += data;
-      });
-
-      // Wait for the app to be ready by looking for the initial prompt indicator
-      await rig.poll(() => output.includes('▶'), 5000, 100);
-
-      ptyProcess.write('use the tool to run "node -e wait.js"\n');
-
-      await rig.poll(() => output.includes('Shell'), 5000, 100);
-
-      // Send first Ctrl+C
-      ptyProcess.write(String.fromCharCode(3));
-
-      // Wait for the exit prompt
-      await rig.poll(
-        () => output.includes('Press Ctrl+C again to exit'),
-        1500,
-        50,
-      );
-
-      // Send second Ctrl+C
-      ptyProcess.write(String.fromCharCode(3));
-
-      const result = await promise;
-
-      // Expect a graceful exit (code 0)
-      expect(
-        result.exitCode,
-        `Process exited with code ${result.exitCode}. Output: ${result.output}`,
-      ).toBe(0);
-
-      // Check that the quitting message is displayed
-      const quittingMessage = 'Agent powering down. Goodbye!';
-      // The regex below is intentionally matching the ESC control character (\x1b)
-      // to strip ANSI color codes from the terminal output.
-      // eslint-disable-next-line no-control-regex
-      const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
-      expect(cleanOutput).toContain(quittingMessage);
-
-      // Check that the child process was terminated and did not create the file.
-      const childProcessFileExists = fs.existsSync(
-        path.join(rig.testDir!, childProcessFile),
-      );
-      expect(
-        childProcessFileExists,
-        'Child process file should not exist',
-      ).toBe(false);
-    },
-  );
+    // Check that the quitting message is displayed
+    const quittingMessage = 'Agent powering down. Goodbye!';
+    // The regex below is intentionally matching the ESC control character (\x1b)
+    // to strip ANSI color codes from the terminal output.
+    // eslint-disable-next-line no-control-regex
+    const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+    expect(cleanOutput).toContain(quittingMessage);
+  });
 });

integration-tests/globalSetup.ts

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -30,6 +30,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const rootDir = join(__dirname, '..');
 const integrationTestsDir = join(rootDir, '.integration-tests');
 let runDir = ''; // Make runDir accessible in teardown
+let sdkE2eRunDir = ''; // SDK E2E test run directory
 
 const memoryFilePath = join(
   os.homedir(),
@@ -48,14 +49,36 @@ export async function setup() {
     // File doesn't exist, which is fine.
   }
 
+  // Setup for CLI integration tests
   runDir = join(integrationTestsDir, `${Date.now()}`);
   await mkdir(runDir, { recursive: true });
 
+  // Setup for SDK E2E tests (separate directory with prefix)
+  sdkE2eRunDir = join(integrationTestsDir, `sdk-e2e-${Date.now()}`);
+  await mkdir(sdkE2eRunDir, { recursive: true });
+
   // Clean up old test runs, but keep the latest few for debugging
   try {
     const testRuns = await readdir(integrationTestsDir);
-    if (testRuns.length > 5) {
-      const oldRuns = testRuns.sort().slice(0, testRuns.length - 5);
+
+    // Clean up old CLI integration test runs (without sdk-e2e- prefix)
+    const cliTestRuns = testRuns.filter((run) => !run.startsWith('sdk-e2e-'));
+    if (cliTestRuns.length > 5) {
+      const oldRuns = cliTestRuns.sort().slice(0, cliTestRuns.length - 5);
+      await Promise.all(
+        oldRuns.map((oldRun) =>
+          rm(join(integrationTestsDir, oldRun), {
+            recursive: true,
+            force: true,
+          }),
+        ),
+      );
+    }
+
+    // Clean up old SDK E2E test runs (with sdk-e2e- prefix)
+    const sdkTestRuns = testRuns.filter((run) => run.startsWith('sdk-e2e-'));
+    if (sdkTestRuns.length > 5) {
+      const oldRuns = sdkTestRuns.sort().slice(0, sdkTestRuns.length - 5);
       await Promise.all(
         oldRuns.map((oldRun) =>
           rm(join(integrationTestsDir, oldRun), {
@@ -69,24 +92,37 @@ export async function setup() {
     console.error('Error cleaning up old test runs:', e);
   }
 
+  // Environment variables for CLI integration tests
   process.env['INTEGRATION_TEST_FILE_DIR'] = runDir;
   process.env['GEMINI_CLI_INTEGRATION_TEST'] = 'true';
   process.env['TELEMETRY_LOG_FILE'] = join(runDir, 'telemetry.log');
 
+  // Environment variables for SDK E2E tests
+  process.env['E2E_TEST_FILE_DIR'] = sdkE2eRunDir;
+  process.env['TEST_CLI_PATH'] = join(rootDir, 'dist/cli.js');
+
   if (process.env['KEEP_OUTPUT']) {
     console.log(`Keeping output for test run in: ${runDir}`);
+    console.log(`Keeping output for SDK E2E test run in: ${sdkE2eRunDir}`);
   }
   process.env['VERBOSE'] = process.env['VERBOSE'] ?? 'false';
 
   console.log(`\nIntegration test output directory: ${runDir}`);
+  console.log(`SDK E2E test output directory: ${sdkE2eRunDir}`);
+  console.log(`CLI path: ${process.env['TEST_CLI_PATH']}`);
 }
 
 export async function teardown() {
-  // Cleanup the test run directory unless KEEP_OUTPUT is set
+  // Cleanup the CLI test run directory unless KEEP_OUTPUT is set
   if (process.env['KEEP_OUTPUT'] !== 'true' && runDir) {
     await rm(runDir, { recursive: true, force: true });
   }
 
+  // Cleanup the SDK E2E test run directory unless KEEP_OUTPUT is set
+  if (process.env['KEEP_OUTPUT'] !== 'true' && sdkE2eRunDir) {
+    await rm(sdkE2eRunDir, { recursive: true, force: true });
+  }
+
   if (originalMemoryContent !== null) {
     await mkdir(dirname(memoryFilePath), { recursive: true });
     await writeFile(memoryFilePath, originalMemoryContent, 'utf-8');

integration-tests/json-output.test.ts

@@ -53,82 +53,6 @@ describe('JSON output', () => {
     }
   });
 
-  it('should return a JSON error for enforced auth mismatch before running', async () => {
-    const originalOpenaiApiKey = process.env['OPENAI_API_KEY'];
-    process.env['OPENAI_API_KEY'] = 'test-key';
-    await rig.setup('json-output-auth-mismatch', {
-      settings: {
-        security: { auth: { enforcedType: 'qwen-oauth' } },
-      },
-    });
-
-    let thrown: Error | undefined;
-    try {
-      await rig.run('Hello', '--output-format', 'json');
-      expect.fail('Expected process to exit with error');
-    } catch (e) {
-      thrown = e as Error;
-    } finally {
-      process.env['OPENAI_API_KEY'] = originalOpenaiApiKey;
-    }
-
-    expect(thrown).toBeDefined();
-    const message = (thrown as Error).message;
-
-    // The error JSON is written to stdout as a CLIResultMessageError
-    // Extract stdout from the error message
-    const stdoutMatch = message.match(/Stdout:\n([\s\S]*?)(?:\n\nStderr:|$)/);
-    expect(
-      stdoutMatch,
-      'Expected to find stdout in the error message',
-    ).toBeTruthy();
-
-    const stdout = stdoutMatch![1];
-    let parsed: unknown[];
-    try {
-      // Parse the JSON array from stdout
-      parsed = JSON.parse(stdout);
-    } catch (parseError) {
-      console.error('Failed to parse the following JSON:', stdout);
-      throw new Error(
-        `Test failed: Could not parse JSON from stdout. Details: ${parseError}`,
-      );
-    }
-
-    // The output should be an array of messages
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBeGreaterThan(0);
-
-    // Find the result message with error
-    const resultMessage = parsed.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'result' &&
-        'is_error' in msg &&
-        msg.is_error === true,
-    ) as {
-      type: string;
-      is_error: boolean;
-      subtype: string;
-      error?: { message: string; type?: string };
-    };
-
-    expect(resultMessage).toBeDefined();
-    expect(resultMessage.is_error).toBe(true);
-    expect(resultMessage).toHaveProperty('subtype');
-    expect(resultMessage.subtype).toBe('error_during_execution');
-    expect(resultMessage).toHaveProperty('error');
-    expect(resultMessage.error).toBeDefined();
-    expect(resultMessage.error?.message).toContain(
-      'configured auth type is qwen-oauth',
-    );
-    expect(resultMessage.error?.message).toContain(
-      'current auth type is openai',
-    );
-  });
-
   it('should return line-delimited JSON messages for stream-json output format', async () => {
     const result = await rig.run(
       'What is the capital of France?',
@@ -307,4 +231,80 @@ describe('JSON output', () => {
     expect(resultMessage).toHaveProperty('result');
     expect(resultMessage.result.toLowerCase()).toContain('paris');
   });
+
+  it('should return a JSON error for enforced auth mismatch before running', async () => {
+    const originalOpenaiApiKey = process.env['OPENAI_API_KEY'];
+    process.env['OPENAI_API_KEY'] = 'test-key';
+    await rig.setup('json-output-auth-mismatch', {
+      settings: {
+        security: { auth: { enforcedType: 'qwen-oauth' } },
+      },
+    });
+
+    let thrown: Error | undefined;
+    try {
+      await rig.run('Hello', '--output-format', 'json');
+      expect.fail('Expected process to exit with error');
+    } catch (e) {
+      thrown = e as Error;
+    } finally {
+      process.env['OPENAI_API_KEY'] = originalOpenaiApiKey;
+    }
+
+    expect(thrown).toBeDefined();
+    const message = (thrown as Error).message;
+
+    // The error JSON is written to stdout as a CLIResultMessageError
+    // Extract stdout from the error message
+    const stdoutMatch = message.match(/Stdout:\n([\s\S]*?)(?:\n\nStderr:|$)/);
+    expect(
+      stdoutMatch,
+      'Expected to find stdout in the error message',
+    ).toBeTruthy();
+
+    const stdout = stdoutMatch![1];
+    let parsed: unknown[];
+    try {
+      // Parse the JSON array from stdout
+      parsed = JSON.parse(stdout);
+    } catch (parseError) {
+      console.error('Failed to parse the following JSON:', stdout);
+      throw new Error(
+        `Test failed: Could not parse JSON from stdout. Details: ${parseError}`,
+      );
+    }
+
+    // The output should be an array of messages
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBeGreaterThan(0);
+
+    // Find the result message with error
+    const resultMessage = parsed.find(
+      (msg: unknown) =>
+        typeof msg === 'object' &&
+        msg !== null &&
+        'type' in msg &&
+        msg.type === 'result' &&
+        'is_error' in msg &&
+        msg.is_error === true,
+    ) as {
+      type: string;
+      is_error: boolean;
+      subtype: string;
+      error?: { message: string; type?: string };
+    };
+
+    expect(resultMessage).toBeDefined();
+    expect(resultMessage.is_error).toBe(true);
+    expect(resultMessage).toHaveProperty('subtype');
+    expect(resultMessage.subtype).toBe('error_during_execution');
+    expect(resultMessage).toHaveProperty('error');
+    expect(resultMessage.error).toBeDefined();
+    expect(resultMessage.error?.message).toContain(
+      'configured auth type is qwen-oauth',
+    );
+    expect(resultMessage.error?.message).toContain(
+      'current auth type is openai',
+    );
+  });
 });

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

@@ -0,0 +1,486 @@
+/**
+ * E2E tests based on abort-and-lifecycle.ts example
+ * Tests AbortController integration and process lifecycle management
+ */
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  AbortError,
+  isAbortError,
+  isSDKAssistantMessage,
+  type TextBlock,
+  type ContentBlock,
+} from '@qwen-code/sdk';
+import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+describe('AbortController and Process Lifecycle (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('abort-and-lifecycle');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+  describe('Basic AbortController Usage', () => {
+    it('should support AbortController cancellation', async () => {
+      const controller = new AbortController();
+
+      // Abort after 5 seconds
+      setTimeout(() => {
+        controller.abort();
+      }, 5000);
+
+      const q = query({
+        prompt: 'Write a very long story about TypeScript programming',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            const textBlocks = message.message.content.filter(
+              (block): block is TextBlock => block.type === 'text',
+            );
+            const text = textBlocks
+              .map((b) => b.text)
+              .join('')
+              .slice(0, 100);
+
+            // Should receive some content before abort
+            expect(text.length).toBeGreaterThan(0);
+          }
+        }
+
+        // Should not reach here - query should be aborted
+        expect(false).toBe(true);
+      } catch (error) {
+        expect(isAbortError(error)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle abort during query execution', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      let receivedFirstMessage = false;
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            if (!receivedFirstMessage) {
+              // Abort immediately after receiving first assistant message
+              receivedFirstMessage = true;
+              controller.abort();
+            }
+          }
+        }
+      } catch (error) {
+        expect(isAbortError(error)).toBe(true);
+        expect(error instanceof AbortError).toBe(true);
+        // Should have received at least one message before abort
+        expect(receivedFirstMessage).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle abort immediately after query starts', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Write a very long essay',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      // Abort immediately after query initialization
+      setTimeout(() => {
+        controller.abort();
+      }, 200);
+
+      try {
+        for await (const _message of q) {
+          // May or may not receive messages before abort
+        }
+      } catch (error) {
+        expect(isAbortError(error)).toBe(true);
+        expect(error instanceof AbortError).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Process Lifecycle Monitoring', () => {
+    it('should handle normal process completion', async () => {
+      const q = query({
+        prompt: 'Why do we choose to go to the moon?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let completedSuccessfully = false;
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            const textBlocks = message.message.content.filter(
+              (block): block is TextBlock => block.type === 'text',
+            );
+            const text = textBlocks
+              .map((b) => b.text)
+              .join('')
+              .slice(0, 100);
+            expect(text.length).toBeGreaterThan(0);
+          }
+        }
+
+        completedSuccessfully = true;
+      } catch (error) {
+        // Should not throw for normal completion
+        expect(false).toBe(true);
+      } finally {
+        await q.close();
+        expect(completedSuccessfully).toBe(true);
+      }
+    });
+
+    it('should handle process cleanup after error', async () => {
+      const q = query({
+        prompt: 'Hello world',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            const textBlocks = message.message.content.filter(
+              (block): block is TextBlock => block.type === 'text',
+            );
+            const text = textBlocks
+              .map((b) => b.text)
+              .join('')
+              .slice(0, 50);
+            expect(text.length).toBeGreaterThan(0);
+          }
+        }
+      } catch (error) {
+        // Expected to potentially have errors
+      } finally {
+        // Should cleanup successfully even after error
+        await q.close();
+        expect(true).toBe(true); // Cleanup completed
+      }
+    });
+  });
+
+  describe('Input Stream Control', () => {
+    it('should support endInput() method', async () => {
+      const q = query({
+        prompt: 'What is 2 + 2?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let receivedResponse = false;
+      let endInputCalled = false;
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message) && !endInputCalled) {
+            const textBlocks = message.message.content.filter(
+              (block: ContentBlock): block is TextBlock =>
+                block.type === 'text',
+            );
+            const text = textBlocks.map((b: TextBlock) => b.text).join('');
+
+            expect(text.length).toBeGreaterThan(0);
+            receivedResponse = true;
+
+            // End input after receiving first response
+            q.endInput();
+            endInputCalled = true;
+          }
+        }
+
+        expect(receivedResponse).toBe(true);
+        expect(endInputCalled).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Error Handling and Recovery', () => {
+    it('should handle invalid executable path', async () => {
+      try {
+        const q = query({
+          prompt: 'Hello world',
+          options: {
+            pathToQwenExecutable: '/nonexistent/path/to/cli',
+            debug: false,
+          },
+        });
+
+        // Should not reach here - query() should throw immediately
+        for await (const _message of q) {
+          // Should not reach here
+        }
+
+        // Should not reach here
+        expect(false).toBe(true);
+      } catch (error) {
+        expect(error instanceof Error).toBe(true);
+        expect((error as Error).message).toBeDefined();
+        expect((error as Error).message).toContain(
+          'Invalid pathToQwenExecutable',
+        );
+      }
+    });
+
+    it('should throw AbortError with correct properties', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Explain the concept of async programming',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      // Abort after allowing query to start
+      setTimeout(() => controller.abort(), 1000);
+
+      try {
+        for await (const _message of q) {
+          // May receive some messages before abort
+        }
+      } catch (error) {
+        // Verify error type and helper functions
+        expect(isAbortError(error)).toBe(true);
+        expect(error instanceof AbortError).toBe(true);
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBeDefined();
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Debugging with stderr callback', () => {
+    it('should capture stderr messages when debug is enabled', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Why do we choose to go to the moon?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            const textBlocks = message.message.content.filter(
+              (block): block is TextBlock => block.type === 'text',
+            );
+            const text = textBlocks
+              .map((b) => b.text)
+              .join('')
+              .slice(0, 50);
+            expect(text.length).toBeGreaterThan(0);
+          }
+        }
+      } finally {
+        await q.close();
+        expect(stderrMessages.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should not capture stderr when debug is disabled', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      try {
+        for await (const _message of q) {
+          // Consume all messages
+        }
+      } finally {
+        await q.close();
+        // Should have minimal or no stderr output when debug is false
+        expect(stderrMessages.length).toBeLessThan(10);
+      }
+    });
+  });
+
+  describe('Abort with Cleanup', () => {
+    it('should cleanup properly after abort', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Write a very long essay about programming',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      // Abort immediately
+      setTimeout(() => controller.abort(), 100);
+
+      try {
+        for await (const _message of q) {
+          // May receive some messages before abort
+        }
+      } catch (error) {
+        if (error instanceof AbortError) {
+          expect(true).toBe(true); // Expected abort error
+        } else {
+          throw error; // Unexpected error
+        }
+      } finally {
+        await q.close();
+        expect(true).toBe(true); // Cleanup completed after abort
+      }
+    });
+
+    it('should handle multiple abort calls gracefully', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Count to 100',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      // Multiple abort calls
+      setTimeout(() => controller.abort(), 100);
+      setTimeout(() => controller.abort(), 200);
+      setTimeout(() => controller.abort(), 300);
+
+      try {
+        for await (const _message of q) {
+          // Should be interrupted
+        }
+      } catch (error) {
+        expect(isAbortError(error)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Resource Management Edge Cases', () => {
+    it('should handle close() called multiple times', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      // Start the query
+      const iterator = q[Symbol.asyncIterator]();
+      await iterator.next();
+
+      // Close multiple times
+      await q.close();
+      await q.close();
+      await q.close();
+
+      // Should not throw
+      expect(true).toBe(true);
+    });
+
+    it('should handle abort after close', async () => {
+      const controller = new AbortController();
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          abortController: controller,
+          debug: false,
+        },
+      });
+
+      // Start and close immediately
+      const iterator = q[Symbol.asyncIterator]();
+      await iterator.next();
+      await q.close();
+
+      // Abort after close
+      controller.abort();
+
+      // Should not throw
+      expect(true).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,640 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * E2E tests for SDK configuration options:
+ * - logLevel: Controls SDK internal logging verbosity
+ * - env: Environment variables passed to CLI process
+ * - authType: Authentication type for AI service
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKAssistantMessage,
+  isSDKSystemMessage,
+  type SDKMessage,
+} from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  extractText,
+  createSharedTestOptions,
+  assertSuccessfulCompletion,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+describe('Configuration Options (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('configuration-options');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+
+  describe('logLevel Option', () => {
+    it('should respect logLevel: debug and capture detailed logs', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'What is 1 + 1? Just answer the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'debug',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Debug level should produce verbose logging
+        expect(stderrMessages.length).toBeGreaterThan(0);
+
+        // Debug logs should contain detailed information like [DEBUG]
+        const hasDebugLogs = stderrMessages.some(
+          (msg) => msg.includes('[DEBUG]') || msg.includes('debug'),
+        );
+        expect(hasDebugLogs).toBe(true);
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should respect logLevel: info and filter out debug messages', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'What is 2 + 2? Just answer the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'info',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Info level should filter out debug messages
+        // Check that we don't have [DEBUG] level messages from the SDK logger
+        const sdkDebugLogs = stderrMessages.filter(
+          (msg) =>
+            msg.includes('[DEBUG]') && msg.includes('[ProcessTransport]'),
+        );
+        expect(sdkDebugLogs.length).toBe(0);
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should respect logLevel: warn and only show warnings and errors', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'warn',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Warn level should filter out info and debug messages from SDK
+        const sdkInfoOrDebugLogs = stderrMessages.filter(
+          (msg) =>
+            (msg.includes('[DEBUG]') || msg.includes('[INFO]')) &&
+            (msg.includes('[ProcessTransport]') ||
+              msg.includes('[createQuery]') ||
+              msg.includes('[Query]')),
+        );
+        expect(sdkInfoOrDebugLogs.length).toBe(0);
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should respect logLevel: error and only show error messages', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello world',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'error',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Error level should filter out all non-error messages from SDK
+        const sdkNonErrorLogs = stderrMessages.filter(
+          (msg) =>
+            (msg.includes('[DEBUG]') ||
+              msg.includes('[INFO]') ||
+              msg.includes('[WARN]')) &&
+            (msg.includes('[ProcessTransport]') ||
+              msg.includes('[createQuery]') ||
+              msg.includes('[Query]')),
+        );
+        expect(sdkNonErrorLogs.length).toBe(0);
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should use logLevel over debug flag when both are provided', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'What is 3 + 3?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: true, // Would normally enable debug logging
+          logLevel: 'error', // But logLevel should take precedence
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      try {
+        for await (const _message of q) {
+          // Consume all messages
+        }
+
+        // logLevel: error should suppress debug/info/warn even with debug: true
+        const sdkNonErrorLogs = stderrMessages.filter(
+          (msg) =>
+            (msg.includes('[DEBUG]') ||
+              msg.includes('[INFO]') ||
+              msg.includes('[WARN]')) &&
+            (msg.includes('[ProcessTransport]') ||
+              msg.includes('[createQuery]') ||
+              msg.includes('[Query]')),
+        );
+        expect(sdkNonErrorLogs.length).toBe(0);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('env Option', () => {
+    it('should pass custom environment variables to CLI process', async () => {
+      const q = query({
+        prompt: 'What is 1 + 1? Just the number please.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {
+            CUSTOM_TEST_VAR: 'test_value_12345',
+            ANOTHER_VAR: 'another_value',
+          },
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // The query should complete successfully with custom env vars
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should allow overriding existing environment variables', async () => {
+      // Store original value for comparison
+      const originalPath = process.env['PATH'];
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {
+            // Override an existing env var (not PATH as it might break things)
+            MY_TEST_OVERRIDE: 'overridden_value',
+          },
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Query should complete successfully
+        assertSuccessfulCompletion(messages);
+
+        // Verify original process env is not modified
+        expect(process.env['PATH']).toBe(originalPath);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should work with empty env object', async () => {
+      const q = query({
+        prompt: 'What is 2 + 2?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {},
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should support setting model-related environment variables', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {
+            // Common model-related env vars that CLI might respect
+            OPENAI_API_KEY: process.env['OPENAI_API_KEY'] || 'test-key',
+          },
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Should complete (may succeed or fail based on API key validity)
+        expect(messages.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should not leak env vars between query instances', async () => {
+      // First query with specific env var
+      const q1 = query({
+        prompt: 'Say one',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {
+            ISOLATED_VAR_1: 'value_1',
+          },
+          debug: false,
+        },
+      });
+
+      try {
+        for await (const _message of q1) {
+          // Consume messages
+        }
+      } finally {
+        await q1.close();
+      }
+
+      // Second query with different env var
+      const q2 = query({
+        prompt: 'Say two',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          env: {
+            ISOLATED_VAR_2: 'value_2',
+          },
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q2) {
+          messages.push(message);
+        }
+
+        // Second query should complete successfully
+        assertSuccessfulCompletion(messages);
+
+        // Verify process.env is not polluted by either query
+        expect(process.env['ISOLATED_VAR_1']).toBeUndefined();
+        expect(process.env['ISOLATED_VAR_2']).toBeUndefined();
+      } finally {
+        await q2.close();
+      }
+    });
+  });
+
+  describe('authType Option', () => {
+    it('should accept authType: openai', async () => {
+      const q = query({
+        prompt: 'What is 1 + 1? Just the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          authType: 'openai',
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Query should complete with openai auth type
+        assertSuccessfulCompletion(messages);
+
+        // Verify we got an assistant response
+        const assistantMessages = messages.filter(isSDKAssistantMessage);
+        expect(assistantMessages.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+
+    // Skip in containerized sandbox environments - qwen-oauth requires user interaction
+    // which is not possible in Docker/Podman CI environments
+    it.skipIf(
+      process.env['SANDBOX'] === 'sandbox:docker' ||
+        process.env['SANDBOX'] === 'sandbox:podman',
+    )('should accept authType: qwen-oauth', async () => {
+      // Note: qwen-oauth requires credentials in ~/.qwen and user interaction
+      // Without credentials, the auth process will timeout waiting for user
+      // This test verifies the option is accepted and passed correctly to CLI
+
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          authType: 'qwen-oauth',
+          debug: true,
+          logLevel: 'debug',
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        // Use a timeout to avoid hanging when credentials are not configured
+        const timeoutPromise = new Promise<'timeout'>((resolve) =>
+          setTimeout(() => resolve('timeout'), 20000),
+        );
+
+        const collectMessages = async () => {
+          for await (const message of q) {
+            messages.push(message);
+          }
+          return 'completed';
+        };
+
+        const result = await Promise.race([collectMessages(), timeoutPromise]);
+
+        if (result === 'timeout') {
+          // Timeout is expected when OAuth credentials are not configured
+          // Verify that CLI was spawned with correct --auth-type argument
+          const hasAuthTypeArg = stderrMessages.some((msg) =>
+            msg.includes('--auth-type'),
+          );
+          expect(hasAuthTypeArg).toBe(true);
+        } else {
+          // If credentials exist and auth completed, verify we got messages
+          expect(messages.length).toBeGreaterThan(0);
+        }
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should use default auth when authType is not specified', async () => {
+      const q = query({
+        prompt: 'What is 2 + 2? Just the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          // authType not specified - should use default
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Query should complete with default auth
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should properly pass authType to CLI process', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Say hi',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          authType: 'openai',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // There should be spawn log containing auth-type
+        const hasAuthTypeArg = stderrMessages.some((msg) =>
+          msg.includes('--auth-type'),
+        );
+        expect(hasAuthTypeArg).toBe(true);
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Combined Options', () => {
+    it('should work with logLevel, env, and authType together', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'What is 3 + 3? Just the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'debug',
+          env: {
+            COMBINED_TEST_VAR: 'combined_value',
+          },
+          authType: 'openai',
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // All three options should work together
+        expect(stderrMessages.length).toBeGreaterThan(0); // logLevel: debug produces logs
+        expect(assistantText).toMatch(/6/); // Query should work
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should maintain system message consistency with all options', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          logLevel: 'info',
+          env: {
+            SYSTEM_MSG_TEST: 'test',
+          },
+          authType: 'openai',
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Should have system init message
+        const systemMessages = messages.filter(isSDKSystemMessage);
+        const initMessage = systemMessages.find((m) => m.subtype === 'init');
+
+        expect(initMessage).toBeDefined();
+        expect(initMessage!.session_id).toBeDefined();
+        expect(initMessage!.tools).toBeDefined();
+        expect(initMessage!.permission_mode).toBeDefined();
+
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,405 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * E2E tests for MCP (Model Context Protocol) server integration via SDK
+ * Tests that the SDK can properly interact with MCP servers configured in qwen-code
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKAssistantMessage,
+  isSDKResultMessage,
+  isSDKSystemMessage,
+  isSDKUserMessage,
+  type SDKMessage,
+  type ToolUseBlock,
+  type SDKSystemMessage,
+} from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  createMCPServer,
+  extractText,
+  findToolUseBlocks,
+  createSharedTestOptions,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = {
+  ...createSharedTestOptions(),
+  permissionMode: 'yolo' as const,
+};
+
+describe('MCP Server Integration (E2E)', () => {
+  let helper: SDKTestHelper;
+  let serverScriptPath: string;
+  let testDir: string;
+
+  beforeEach(async () => {
+    // Create isolated test environment using SDKTestHelper
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('mcp-server-integration');
+
+    // Create MCP server using the helper utility
+    const mcpServer = await createMCPServer(helper, 'math', 'test-math-server');
+    serverScriptPath = mcpServer.scriptPath;
+  });
+
+  afterEach(async () => {
+    // Cleanup test directory
+    await helper.cleanup();
+  });
+
+  describe('Basic MCP Tool Usage', () => {
+    it('should use MCP add tool to add two numbers', async () => {
+      const q = query({
+        prompt:
+          'Use the add tool to calculate 5 + 10. Just give me the result.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      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, 'add');
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate tool was called
+        expect(foundToolUse).toBe(true);
+
+        // Validate result contains expected answer
+        expect(assistantText).toMatch(/15/);
+
+        // 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 MCP multiply tool to multiply two numbers', async () => {
+      const q = query({
+        prompt:
+          'Use the multiply tool to calculate 6 * 7. Just give me the result.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      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, 'multiply');
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+            }
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate tool was called
+        expect(foundToolUse).toBe(true);
+
+        // Validate result contains expected answer
+        expect(assistantText).toMatch(/42/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('MCP Server Discovery', () => {
+    it('should list MCP servers in system init message', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      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 test server
+        const testServer = systemMessage!.mcp_servers?.find(
+          (server) => server.name === 'test-math-server',
+        );
+        expect(testServer).toBeDefined();
+
+        // Note: tools are not exposed in the mcp_servers array in system message
+        // They are available through the MCP protocol but not in the init message
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Complex MCP Operations', () => {
+    it('should chain multiple MCP tool calls', async () => {
+      const q = query({
+        prompt:
+          'First use add to calculate 10 + 5, then multiply the result by 2. Give me the final answer.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      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('add');
+        expect(toolCalls).toContain('multiply');
+
+        // Validate result: (10 + 5) * 2 = 30
+        expect(assistantText).toMatch(/30/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle multiple calls to the same MCP tool', async () => {
+      const q = query({
+        prompt:
+          'Use the add tool twice: first add 1 + 2, then add 3 + 4. Tell me both results.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+      const addToolCalls: ToolUseBlock[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message, 'add');
+            addToolCalls.push(...toolUseBlocks);
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate add tool was called at least twice
+        expect(addToolCalls.length).toBeGreaterThanOrEqual(2);
+
+        // Validate results contain expected answers: 3 and 7
+        expect(assistantText).toMatch(/3/);
+        expect(assistantText).toMatch(/7/);
+
+        // Validate successful completion
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('MCP Tool Message Flow', () => {
+    it('should receive proper message sequence for MCP tool usage', async () => {
+      const q = query({
+        prompt: 'Use add to calculate 2 + 3',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      const messageTypes: string[] = [];
+      let foundToolUse = false;
+      let foundToolResult = false;
+
+      try {
+        for await (const message of q) {
+          messageTypes.push(message.type);
+
+          if (isSDKAssistantMessage(message)) {
+            const toolUseBlocks = findToolUseBlocks(message);
+            if (toolUseBlocks.length > 0) {
+              foundToolUse = true;
+              expect(toolUseBlocks[0].name).toBe('add');
+              expect(toolUseBlocks[0].input).toBeDefined();
+            }
+          }
+
+          if (isSDKUserMessage(message)) {
+            const content = message.message.content;
+            const contentArray = Array.isArray(content)
+              ? content
+              : [{ type: 'text', text: content }];
+            const toolResultBlock = contentArray.find(
+              (block) => block.type === 'tool_result',
+            );
+            if (toolResultBlock) {
+              foundToolResult = true;
+            }
+          }
+        }
+
+        // Validate message flow
+        expect(foundToolUse).toBe(true);
+        expect(foundToolResult).toBe(true);
+        expect(messageTypes).toContain('system');
+        expect(messageTypes).toContain('assistant');
+        expect(messageTypes).toContain('user');
+        expect(messageTypes).toContain('result');
+
+        // Result should be last message
+        expect(messageTypes[messageTypes.length - 1]).toBe('result');
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle gracefully when MCP tool is not available', async () => {
+      const q = query({
+        prompt: 'Use the subtract tool to calculate 10 - 5',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+          mcpServers: {
+            'test-math-server': {
+              command: 'node',
+              args: [serverScriptPath],
+            },
+          },
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Should complete without crashing
+        const lastMessage = messages[messages.length - 1];
+        expect(isSDKResultMessage(lastMessage)).toBe(true);
+
+        // Assistant should indicate tool is not available or provide alternative
+        expect(assistantText.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,559 @@
+/**
+ * E2E tests based on multi-turn.ts example
+ * Tests multi-turn conversation functionality with real CLI
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKUserMessage,
+  isSDKAssistantMessage,
+  isSDKSystemMessage,
+  isSDKResultMessage,
+  isSDKPartialAssistantMessage,
+  isControlRequest,
+  isControlResponse,
+  isControlCancel,
+  type SDKUserMessage,
+  type SDKAssistantMessage,
+  type TextBlock,
+  type ContentBlock,
+  type SDKMessage,
+  type ControlMessage,
+  type ToolUseBlock,
+} from '@qwen-code/sdk';
+import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+/**
+ * Determine the message type using protocol type guards
+ */
+function getMessageType(message: SDKMessage | ControlMessage): string {
+  if (isSDKUserMessage(message)) {
+    return '🧑 USER';
+  } else if (isSDKAssistantMessage(message)) {
+    return '🤖 ASSISTANT';
+  } else if (isSDKSystemMessage(message)) {
+    return `🖥️ SYSTEM(${message.subtype})`;
+  } else if (isSDKResultMessage(message)) {
+    return `✅ RESULT(${message.subtype})`;
+  } else if (isSDKPartialAssistantMessage(message)) {
+    return '⏳ STREAM_EVENT';
+  } else if (isControlRequest(message)) {
+    return `🎮 CONTROL_REQUEST(${message.request.subtype})`;
+  } else if (isControlResponse(message)) {
+    return `📭 CONTROL_RESPONSE(${message.response.subtype})`;
+  } else if (isControlCancel(message)) {
+    return '🛑 CONTROL_CANCEL';
+  } else {
+    return '❓ UNKNOWN';
+  }
+}
+
+/**
+ * Helper to extract text from ContentBlock array
+ */
+function extractText(content: ContentBlock[]): string {
+  return content
+    .filter((block): block is TextBlock => block.type === 'text')
+    .map((block) => block.text)
+    .join('');
+}
+
+describe('Multi-Turn Conversations (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('multi-turn');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+
+  describe('AsyncIterable Prompt Support', () => {
+    it('should handle multi-turn conversation using AsyncIterable prompt', async () => {
+      // Create multi-turn conversation generator
+      async function* createMultiTurnConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'What is 1 + 1?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'What is 2 + 2?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'What is 3 + 3?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      // Create multi-turn query using AsyncIterable prompt
+      const q = query({
+        prompt: createMultiTurnConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      const assistantMessages: SDKAssistantMessage[] = [];
+      const assistantTexts: string[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantMessages.push(message);
+            const text = extractText(message.message.content);
+            assistantTexts.push(text);
+          }
+        }
+
+        expect(messages.length).toBeGreaterThan(0);
+        expect(assistantMessages.length).toBeGreaterThanOrEqual(3);
+
+        // Validate content of responses
+        expect(assistantTexts[0]).toMatch(/2/);
+        expect(assistantTexts[1]).toMatch(/4/);
+        expect(assistantTexts[2]).toMatch(/6/);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should maintain session context across turns', async () => {
+      async function* createContextualConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content:
+              'Suppose we have 3 rabbits and 4 carrots. How many animals are there?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'How many animals are there? Only output the number',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createContextualConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const assistantMessages: SDKAssistantMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            assistantMessages.push(message);
+          }
+        }
+
+        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
+
+        // The second response should reference the color blue
+        const secondResponse = extractText(
+          assistantMessages[1].message.content,
+        );
+        expect(secondResponse.toLowerCase()).toContain('3');
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Tool Usage in Multi-Turn', () => {
+    it('should handle tool usage across multiple turns', async () => {
+      async function* createToolConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Create a file named test.txt with content "hello"',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Now read the test.txt file',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createToolConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          permissionMode: 'yolo',
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let toolUseCount = 0;
+      const assistantMessages: SDKAssistantMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantMessages.push(message);
+            const hasToolUseBlock = message.message.content.some(
+              (block: ContentBlock): block is ToolUseBlock =>
+                block.type === 'tool_use',
+            );
+            if (hasToolUseBlock) {
+              toolUseCount++;
+            }
+          }
+        }
+
+        expect(messages.length).toBeGreaterThan(0);
+        expect(toolUseCount).toBeGreaterThan(0);
+        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
+
+        // Validate second response mentions the file content
+        const secondResponse = extractText(
+          assistantMessages[assistantMessages.length - 1].message.content,
+        );
+        expect(secondResponse.toLowerCase()).toMatch(/hello|test\.txt/);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Message Flow and Sequencing', () => {
+    it('should process messages in correct sequence', async () => {
+      async function* createSequentialConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'First question: What is 1 + 1?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Second question: What is 2 + 2?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createSequentialConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messageSequence: string[] = [];
+      const assistantResponses: string[] = [];
+
+      try {
+        for await (const message of q) {
+          const messageType = getMessageType(message);
+          messageSequence.push(messageType);
+
+          if (isSDKAssistantMessage(message)) {
+            const text = extractText(message.message.content);
+            assistantResponses.push(text);
+          }
+        }
+
+        expect(messageSequence.length).toBeGreaterThan(0);
+        expect(assistantResponses.length).toBeGreaterThanOrEqual(2);
+
+        // Should end with result
+        expect(messageSequence[messageSequence.length - 1]).toContain('RESULT');
+
+        // Should have assistant responses
+        expect(messageSequence.some((type) => type.includes('ASSISTANT'))).toBe(
+          true,
+        );
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle conversation completion correctly', async () => {
+      async function* createSimpleConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Hello',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Goodbye',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createSimpleConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let completedNaturally = false;
+      let messageCount = 0;
+
+      try {
+        for await (const message of q) {
+          messageCount++;
+
+          if (isSDKResultMessage(message)) {
+            completedNaturally = true;
+            expect(message.subtype).toBe('success');
+          }
+        }
+
+        expect(messageCount).toBeGreaterThan(0);
+        expect(completedNaturally).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Error Handling in Multi-Turn', () => {
+    it('should handle empty conversation gracefully', async () => {
+      async function* createEmptyConversation(): AsyncIterable<SDKUserMessage> {
+        // Generator that yields nothing
+        /* eslint-disable no-constant-condition */
+        if (false) {
+          yield {} as SDKUserMessage; // Unreachable, but satisfies TypeScript
+        }
+      }
+
+      const q = query({
+        prompt: createEmptyConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Should handle empty conversation without crashing
+        expect(true).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle conversation with delays', async () => {
+      async function* createDelayedConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'First message',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        // Longer delay to test patience
+        await new Promise((resolve) => setTimeout(resolve, 500));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'Second message after delay',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createDelayedConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const assistantMessages: SDKAssistantMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            assistantMessages.push(message);
+          }
+        }
+
+        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Partial Messages in Multi-Turn', () => {
+    it('should receive partial messages when includePartialMessages is enabled', async () => {
+      async function* createMultiTurnConversation(): AsyncIterable<SDKUserMessage> {
+        const sessionId = crypto.randomUUID();
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'What is 1 + 1?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: {
+            role: 'user',
+            content: 'What is 2 + 2?',
+          },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      }
+
+      const q = query({
+        prompt: createMultiTurnConversation(),
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          includePartialMessages: true,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let partialMessageCount = 0;
+      let assistantMessageCount = 0;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKPartialAssistantMessage(message)) {
+            partialMessageCount++;
+          }
+
+          if (isSDKAssistantMessage(message)) {
+            assistantMessageCount++;
+          }
+        }
+
+        expect(messages.length).toBeGreaterThan(0);
+        expect(partialMessageCount).toBeGreaterThan(0);
+        expect(assistantMessageCount).toBeGreaterThanOrEqual(2);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,528 @@
+/**
+ * E2E tests for single-turn query execution
+ * Tests basic query patterns with simple prompts and clear output expectations
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKAssistantMessage,
+  isSDKSystemMessage,
+  isSDKResultMessage,
+  isSDKPartialAssistantMessage,
+  type SDKMessage,
+  type SDKSystemMessage,
+  type SDKAssistantMessage,
+} from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  extractText,
+  createSharedTestOptions,
+  assertSuccessfulCompletion,
+  collectMessagesByType,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+describe('Single-Turn Query (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('single-turn');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+  describe('Simple Text Queries', () => {
+    it('should answer basic arithmetic question', async () => {
+      const q = query({
+        prompt: 'What is 2 + 2? Just give me the number.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: true,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate we got messages
+        expect(messages.length).toBeGreaterThan(0);
+
+        // Validate assistant response content
+        expect(assistantText.length).toBeGreaterThan(0);
+        expect(assistantText).toMatch(/4/);
+
+        // Validate message flow ends with success
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should answer simple factual question', async () => {
+      const q = query({
+        prompt: 'What is the capital of France? One word answer.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate content
+        expect(assistantText.length).toBeGreaterThan(0);
+        expect(assistantText.toLowerCase()).toContain('paris');
+
+        // Validate completion
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle greeting and self-description', async () => {
+      const q = query({
+        prompt: 'Say hello and tell me your name in one sentence.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate content contains greeting
+        expect(assistantText.length).toBeGreaterThan(0);
+        expect(assistantText.toLowerCase()).toMatch(/hello|hi|greetings/);
+
+        // Validate message types
+        const assistantMessages = collectMessagesByType(
+          messages,
+          isSDKAssistantMessage,
+        );
+        expect(assistantMessages.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('System Initialization', () => {
+    it('should receive system message with initialization info', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let systemMessage: SDKSystemMessage | null = null;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKSystemMessage(message) && message.subtype === 'init') {
+            systemMessage = message;
+          }
+        }
+
+        // Validate system message exists and has required fields
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.type).toBe('system');
+        expect(systemMessage!.subtype).toBe('init');
+        expect(systemMessage!.uuid).toBeDefined();
+        expect(systemMessage!.session_id).toBeDefined();
+        expect(systemMessage!.cwd).toBeDefined();
+        expect(systemMessage!.tools).toBeDefined();
+        expect(Array.isArray(systemMessage!.tools)).toBe(true);
+        expect(systemMessage!.mcp_servers).toBeDefined();
+        expect(Array.isArray(systemMessage!.mcp_servers)).toBe(true);
+        expect(systemMessage!.model).toBeDefined();
+        expect(systemMessage!.permission_mode).toBeDefined();
+        expect(systemMessage!.qwen_code_version).toBeDefined();
+
+        // Validate system message appears early in sequence
+        const systemMessageIndex = messages.findIndex(
+          (msg) => isSDKSystemMessage(msg) && msg.subtype === 'init',
+        );
+        expect(systemMessageIndex).toBeGreaterThanOrEqual(0);
+        expect(systemMessageIndex).toBeLessThan(3);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should maintain session ID consistency', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let systemMessage: SDKSystemMessage | null = null;
+      const sessionId = q.getSessionId();
+
+      try {
+        for await (const message of q) {
+          if (isSDKSystemMessage(message) && message.subtype === 'init') {
+            systemMessage = message;
+          }
+        }
+
+        // Validate session IDs are consistent
+        expect(sessionId).toBeDefined();
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.session_id).toBeDefined();
+        expect(systemMessage!.uuid).toBeDefined();
+        expect(systemMessage!.session_id).toBe(systemMessage!.uuid);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Message Flow', () => {
+    it('should follow expected message sequence', async () => {
+      const q = query({
+        prompt: 'Say hi',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messageTypes: string[] = [];
+
+      try {
+        for await (const message of q) {
+          messageTypes.push(message.type);
+        }
+
+        // Validate message sequence
+        expect(messageTypes.length).toBeGreaterThan(0);
+        expect(messageTypes).toContain('assistant');
+        expect(messageTypes[messageTypes.length - 1]).toBe('result');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should complete iteration naturally', async () => {
+      const q = query({
+        prompt: 'Say goodbye',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let completedNaturally = false;
+      let messageCount = 0;
+
+      try {
+        for await (const message of q) {
+          messageCount++;
+
+          if (isSDKResultMessage(message)) {
+            completedNaturally = true;
+            expect(message.subtype).toBe('success');
+          }
+        }
+
+        expect(messageCount).toBeGreaterThan(0);
+        expect(completedNaturally).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Configuration Options', () => {
+    it('should respect debug option and capture stderr', async () => {
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+        },
+      });
+
+      try {
+        for await (const _message of q) {
+          // Consume all messages
+        }
+
+        // Debug mode should produce stderr output
+        expect(stderrMessages.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should respect cwd option', async () => {
+      const q = query({
+        prompt: 'What is 1 + 1?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let hasResponse = false;
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            hasResponse = true;
+          }
+        }
+
+        expect(hasResponse).toBe(true);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should receive partial messages when includePartialMessages is enabled', async () => {
+      const q = query({
+        prompt: 'Count from 1 to 5',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          includePartialMessages: true,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let partialMessageCount = 0;
+      let assistantMessageCount = 0;
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKPartialAssistantMessage(message)) {
+            partialMessageCount++;
+          }
+
+          if (isSDKAssistantMessage(message)) {
+            assistantMessageCount++;
+          }
+        }
+
+        expect(messages.length).toBeGreaterThan(0);
+        expect(partialMessageCount).toBeGreaterThan(0);
+        expect(assistantMessageCount).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Message Type Recognition', () => {
+    it('should correctly identify all message types', async () => {
+      const q = query({
+        prompt: 'What is 5 + 5?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate type guards work correctly
+        const assistantMessages = collectMessagesByType(
+          messages,
+          isSDKAssistantMessage,
+        );
+        const resultMessages = collectMessagesByType(
+          messages,
+          isSDKResultMessage,
+        );
+        const systemMessages = collectMessagesByType(
+          messages,
+          isSDKSystemMessage,
+        );
+
+        expect(assistantMessages.length).toBeGreaterThan(0);
+        expect(resultMessages.length).toBeGreaterThan(0);
+        expect(systemMessages.length).toBeGreaterThan(0);
+
+        // Validate assistant message structure
+        const firstAssistant = assistantMessages[0];
+        expect(firstAssistant.message.content).toBeDefined();
+        expect(Array.isArray(firstAssistant.message.content)).toBe(true);
+
+        // Validate result message structure
+        const resultMessage = resultMessages[0];
+        expect(resultMessage.subtype).toBe('success');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should extract text content from assistant messages', async () => {
+      const q = query({
+        prompt: 'Count from 1 to 3',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      let assistantMessage: SDKAssistantMessage | null = null;
+
+      try {
+        for await (const message of q) {
+          if (isSDKAssistantMessage(message)) {
+            assistantMessage = message;
+          }
+        }
+
+        expect(assistantMessage).not.toBeNull();
+        expect(assistantMessage!.message.content).toBeDefined();
+
+        // Validate content contains expected numbers
+        const text = extractText(assistantMessage!.message.content);
+        expect(text.length).toBeGreaterThan(0);
+        expect(text).toMatch(/1/);
+        expect(text).toMatch(/2/);
+        expect(text).toMatch(/3/);
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should throw if CLI not found', async () => {
+      try {
+        const q = query({
+          prompt: 'Hello',
+          options: {
+            pathToQwenExecutable: '/nonexistent/path/to/cli',
+            debug: false,
+          },
+        });
+
+        for await (const _message of q) {
+          // Should not reach here
+        }
+
+        expect(false).toBe(true); // Should have thrown
+      } catch (error) {
+        expect(error).toBeDefined();
+        expect(error instanceof Error).toBe(true);
+        expect((error as Error).message).toContain(
+          'Invalid pathToQwenExecutable',
+        );
+      }
+    });
+  });
+
+  describe('Resource Management', () => {
+    it('should cleanup subprocess on close()', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      // Start and immediately close
+      const iterator = q[Symbol.asyncIterator]();
+      await iterator.next();
+
+      // Should close without error
+      await q.close();
+      expect(true).toBe(true); // Cleanup completed
+    });
+
+    it('should handle close() called multiple times', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          debug: false,
+        },
+      });
+
+      // Start the query
+      const iterator = q[Symbol.asyncIterator]();
+      await iterator.next();
+
+      // Close multiple times
+      await q.close();
+      await q.close();
+      await q.close();
+
+      // Should not throw
+      expect(true).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,614 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * E2E tests for subagent configuration and execution
+ * Tests subagent delegation and task completion
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKAssistantMessage,
+  type SDKMessage,
+  type SubagentConfig,
+  type ContentBlock,
+  type ToolUseBlock,
+} from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  extractText,
+  createSharedTestOptions,
+  findToolUseBlocks,
+  assertSuccessfulCompletion,
+  findSystemMessage,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+describe('Subagents (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testWorkDir: string;
+
+  beforeEach(async () => {
+    // Create isolated test environment using SDKTestHelper
+    helper = new SDKTestHelper();
+    testWorkDir = await helper.setup('subagent-tests');
+
+    // Create a simple test file for subagent to work with
+    await helper.createFile('test.txt', 'Hello from test file\n');
+  });
+
+  afterEach(async () => {
+    // Cleanup test directory
+    await helper.cleanup();
+  });
+
+  describe('Subagent Configuration', () => {
+    it('should accept session-level subagent configuration', async () => {
+      const simpleSubagent: SubagentConfig = {
+        name: 'simple-greeter',
+        description: 'A simple subagent that responds to greetings',
+        systemPrompt:
+          'You are a friendly greeter. When given a task, respond with a cheerful greeting.',
+        level: 'session',
+      };
+
+      const q = query({
+        prompt: 'Hello, let simple-greeter to say hi back to me.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [simpleSubagent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate system message includes the subagent
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('simple-greeter');
+
+        // Validate successful completion
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should accept multiple subagent configurations', async () => {
+      const greeterAgent: SubagentConfig = {
+        name: 'greeter',
+        description: 'Responds to greetings',
+        systemPrompt: 'You are a friendly greeter.',
+        level: 'session',
+      };
+
+      const mathAgent: SubagentConfig = {
+        name: 'math-helper',
+        description: 'Helps with math problems',
+        systemPrompt: 'You are a math expert. Solve math problems clearly.',
+        level: 'session',
+      };
+
+      const q = query({
+        prompt: 'What is 5 + 5?',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [greeterAgent, mathAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate both subagents are registered
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('greeter');
+        expect(systemMessage!.agents).toContain('math-helper');
+        expect(systemMessage!.agents!.length).toBeGreaterThanOrEqual(2);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle subagent with custom model config', async () => {
+      const customModelAgent: SubagentConfig = {
+        name: 'custom-model-agent',
+        description: 'Agent with custom model configuration',
+        systemPrompt: 'You are a helpful assistant.',
+        level: 'session',
+        modelConfig: {
+          temp: 0.7,
+          top_p: 0.9,
+        },
+      };
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [customModelAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate subagent is registered
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('custom-model-agent');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle subagent with run config', async () => {
+      const limitedAgent: SubagentConfig = {
+        name: 'limited-agent',
+        description: 'Agent with execution limits',
+        systemPrompt: 'You are a helpful assistant.',
+        level: 'session',
+        runConfig: {
+          max_turns: 5,
+          max_time_minutes: 1,
+        },
+      };
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [limitedAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate subagent is registered
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('limited-agent');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle subagent with specific tools', async () => {
+      const toolRestrictedAgent: SubagentConfig = {
+        name: 'read-only-agent',
+        description: 'Agent that can only read files',
+        systemPrompt:
+          'You are a file reading assistant. Read files when asked.',
+        level: 'session',
+        tools: ['read_file', 'list_directory'],
+      };
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [toolRestrictedAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate subagent is registered
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('read-only-agent');
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Subagent Execution', () => {
+    it('should delegate task to subagent when appropriate', async () => {
+      const fileReaderAgent: SubagentConfig = {
+        name: 'file-reader',
+        description: 'Reads and reports file contents',
+        systemPrompt: `You are a file reading assistant. When given a task to read a file, use the read_file tool to read it and report its contents back. Be concise in your response.`,
+        level: 'session',
+        tools: ['read_file', 'list_directory'],
+      };
+
+      const testFile = helper.getPath('test.txt');
+      const q = query({
+        prompt: `Use the file-reader subagent to read the file at ${testFile} and tell me what it contains.`,
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [fileReaderAgent],
+          debug: false,
+          permissionMode: 'yolo',
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let foundTaskTool = false;
+      let taskToolUseId: string | null = null;
+      let foundSubagentToolCall = false;
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            // Check for task tool use in content blocks (main agent calling subagent)
+            const taskToolBlocks = findToolUseBlocks(message, 'task');
+            if (taskToolBlocks.length > 0) {
+              foundTaskTool = true;
+              taskToolUseId = taskToolBlocks[0].id;
+            }
+
+            // Check if this message is from a subagent (has parent_tool_use_id)
+            if (message.parent_tool_use_id !== null) {
+              // This is a subagent message
+              const subagentToolBlocks = findToolUseBlocks(message);
+              if (subagentToolBlocks.length > 0) {
+                foundSubagentToolCall = true;
+                // Verify parent_tool_use_id matches the task tool use id
+                expect(message.parent_tool_use_id).toBe(taskToolUseId);
+              }
+            }
+
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate task tool was used (subagent delegation)
+        expect(foundTaskTool).toBe(true);
+        expect(taskToolUseId).not.toBeNull();
+
+        // Validate subagent actually made tool calls with proper parent_tool_use_id
+        expect(foundSubagentToolCall).toBe(true);
+
+        // Validate we got a response
+        expect(assistantText.length).toBeGreaterThan(0);
+
+        // Validate successful completion
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    }, 60000); // Increase timeout for subagent execution
+
+    it('should complete simple task with subagent', async () => {
+      const simpleTaskAgent: SubagentConfig = {
+        name: 'simple-calculator',
+        description: 'Performs simple arithmetic calculations',
+        systemPrompt:
+          'You are a calculator. When given a math problem, solve it and provide just the answer.',
+        level: 'session',
+      };
+
+      const q = query({
+        prompt: 'Use the simple-calculator subagent to calculate 15 + 27.',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [simpleTaskAgent],
+          debug: false,
+          permissionMode: 'yolo',
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let foundTaskTool = false;
+      let assistantText = '';
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            // Check for task tool use (main agent delegating to subagent)
+            const toolUseBlock = message.message.content.find(
+              (block: ContentBlock): block is ToolUseBlock =>
+                block.type === 'tool_use' && block.name === 'task',
+            );
+            if (toolUseBlock) {
+              foundTaskTool = true;
+            }
+
+            assistantText += extractText(message.message.content);
+          }
+        }
+
+        // Validate task tool was used (subagent was called)
+        expect(foundTaskTool).toBe(true);
+
+        // Validate we got a response
+        expect(assistantText.length).toBeGreaterThan(0);
+
+        // Validate successful completion
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    }, 60000);
+
+    it('should verify subagent execution with comprehensive parent_tool_use_id checks', async () => {
+      const comprehensiveAgent: SubagentConfig = {
+        name: 'comprehensive-agent',
+        description: 'Agent for comprehensive testing',
+        systemPrompt:
+          'You are a helpful assistant. When asked to list files, use the list_directory tool.',
+        level: 'session',
+        tools: ['list_directory', 'read_file'],
+      };
+
+      const q = query({
+        prompt: `Use the comprehensive-agent subagent to list the files in ${testWorkDir}.`,
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [comprehensiveAgent],
+          debug: false,
+          permissionMode: 'yolo',
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+      let taskToolUseId: string | null = null;
+      const subagentToolCalls: ToolUseBlock[] = [];
+      const mainAgentToolCalls: ToolUseBlock[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+
+          if (isSDKAssistantMessage(message)) {
+            // Collect all tool use blocks
+            const toolUseBlocks = message.message.content.filter(
+              (block: ContentBlock): block is ToolUseBlock =>
+                block.type === 'tool_use',
+            );
+
+            for (const toolUse of toolUseBlocks) {
+              if (toolUse.name === 'task') {
+                // This is the main agent calling the subagent
+                taskToolUseId = toolUse.id;
+                mainAgentToolCalls.push(toolUse);
+              }
+
+              // If this message has parent_tool_use_id, it's from a subagent
+              if (message.parent_tool_use_id !== null) {
+                subagentToolCalls.push(toolUse);
+              }
+            }
+          }
+        }
+
+        // Criterion 1: When a subagent is called, there must be a 'task' tool being called
+        expect(taskToolUseId).not.toBeNull();
+        expect(mainAgentToolCalls.length).toBeGreaterThan(0);
+        expect(mainAgentToolCalls.some((tc) => tc.name === 'task')).toBe(true);
+
+        // Criterion 2: A tool call from a subagent is identified by a non-null parent_tool_use_id
+        // All subagent tool calls should have parent_tool_use_id set to the task tool's id
+        expect(subagentToolCalls.length).toBeGreaterThan(0);
+
+        // Verify all subagent messages have the correct parent_tool_use_id
+        const subagentMessages = messages.filter(
+          (msg): msg is SDKMessage & { parent_tool_use_id: string } =>
+            isSDKAssistantMessage(msg) && msg.parent_tool_use_id !== null,
+        );
+
+        expect(subagentMessages.length).toBeGreaterThan(0);
+        for (const subagentMsg of subagentMessages) {
+          expect(subagentMsg.parent_tool_use_id).toBe(taskToolUseId);
+        }
+
+        // Verify no main agent tool calls (except task) have parent_tool_use_id
+        const mainAgentMessages = messages.filter(
+          (msg): msg is SDKMessage =>
+            isSDKAssistantMessage(msg) && msg.parent_tool_use_id === null,
+        );
+
+        for (const mainMsg of mainAgentMessages) {
+          if (isSDKAssistantMessage(mainMsg)) {
+            // Main agent messages should not have parent_tool_use_id
+            expect(mainMsg.parent_tool_use_id).toBeNull();
+          }
+        }
+
+        // Validate successful completion
+        assertSuccessfulCompletion(messages);
+      } finally {
+        await q.close();
+      }
+    }, 60000);
+  });
+
+  describe('Subagent Error Handling', () => {
+    it('should handle empty subagent array', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Should still work with empty agents array
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle subagent with minimal configuration', async () => {
+      const minimalAgent: SubagentConfig = {
+        name: 'minimal-agent',
+        description: 'Minimal configuration agent',
+        systemPrompt: 'You are a helpful assistant.',
+        level: 'session',
+      };
+
+      const q = query({
+        prompt: 'Say hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [minimalAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate minimal agent is registered
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('minimal-agent');
+      } finally {
+        await q.close();
+      }
+    });
+  });
+
+  describe('Subagent Integration', () => {
+    it('should work with other SDK options', async () => {
+      const testAgent: SubagentConfig = {
+        name: 'test-agent',
+        description: 'Test agent for integration',
+        systemPrompt: 'You are a test assistant.',
+        level: 'session',
+      };
+
+      const stderrMessages: string[] = [];
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [testAgent],
+          debug: true,
+          stderr: (msg: string) => {
+            stderrMessages.push(msg);
+          },
+          permissionMode: 'default',
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate subagent works with debug mode
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.agents).toBeDefined();
+        expect(systemMessage!.agents).toContain('test-agent');
+        expect(stderrMessages.length).toBeGreaterThan(0);
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should maintain session consistency with subagents', async () => {
+      const sessionAgent: SubagentConfig = {
+        name: 'session-agent',
+        description: 'Agent for session testing',
+        systemPrompt: 'You are a session test assistant.',
+        level: 'session',
+      };
+
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testWorkDir,
+          agents: [sessionAgent],
+          debug: false,
+        },
+      });
+
+      const messages: SDKMessage[] = [];
+
+      try {
+        for await (const message of q) {
+          messages.push(message);
+        }
+
+        // Validate session consistency
+        const systemMessage = findSystemMessage(messages, 'init');
+        expect(systemMessage).not.toBeNull();
+        expect(systemMessage!.session_id).toBeDefined();
+        expect(systemMessage!.uuid).toBeDefined();
+        expect(systemMessage!.session_id).toBe(systemMessage!.uuid);
+        expect(systemMessage!.agents).toContain('session-agent');
+      } finally {
+        await q.close();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,317 @@
+/**
+ * E2E tests for system controller features:
+ * - setModel API for dynamic model switching
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  query,
+  isSDKAssistantMessage,
+  isSDKSystemMessage,
+  type SDKUserMessage,
+} from '@qwen-code/sdk';
+import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+
+/**
+ * Factory function that creates a streaming input with a control point.
+ * After the first message is yielded, the generator waits for a resume signal,
+ * allowing the test code to call query instance methods like setModel.
+ *
+ * @param firstMessage - The first user message to send
+ * @param secondMessage - The second user message to send after control operations
+ * @returns Object containing the async generator and a resume function
+ */
+function createStreamingInputWithControlPoint(
+  firstMessage: string,
+  secondMessage: string,
+): {
+  generator: AsyncIterable<SDKUserMessage>;
+  resume: () => void;
+} {
+  let resumeResolve: (() => void) | null = null;
+  const resumePromise = new Promise<void>((resolve) => {
+    resumeResolve = resolve;
+  });
+
+  const generator = (async function* () {
+    const sessionId = crypto.randomUUID();
+
+    yield {
+      type: 'user',
+      session_id: sessionId,
+      message: {
+        role: 'user',
+        content: firstMessage,
+      },
+      parent_tool_use_id: null,
+    } as SDKUserMessage;
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    await resumePromise;
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    yield {
+      type: 'user',
+      session_id: sessionId,
+      message: {
+        role: 'user',
+        content: secondMessage,
+      },
+      parent_tool_use_id: null,
+    } as SDKUserMessage;
+  })();
+
+  const resume = () => {
+    if (resumeResolve) {
+      resumeResolve();
+    }
+  };
+
+  return { generator, resume };
+}
+
+describe('System Control (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('system-control');
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+
+  describe('setModel API', () => {
+    it('should change model dynamically during streaming input', async () => {
+      const { generator, resume } = createStreamingInputWithControlPoint(
+        'Tell me the model name.',
+        'Tell me the model name now again.',
+      );
+
+      const q = query({
+        prompt: generator,
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          model: 'qwen3-max',
+          debug: false,
+        },
+      });
+
+      try {
+        const resolvers: {
+          first?: () => void;
+          second?: () => void;
+        } = {};
+        const firstResponsePromise = new Promise<void>((resolve) => {
+          resolvers.first = resolve;
+        });
+        const secondResponsePromise = new Promise<void>((resolve) => {
+          resolvers.second = resolve;
+        });
+
+        let firstResponseReceived = false;
+        let secondResponseReceived = false;
+        const systemMessages: Array<{ model?: string }> = [];
+
+        // Consume messages in a single loop
+        (async () => {
+          for await (const message of q) {
+            if (isSDKSystemMessage(message)) {
+              systemMessages.push({ model: message.model });
+            }
+            if (isSDKAssistantMessage(message)) {
+              if (!firstResponseReceived) {
+                firstResponseReceived = true;
+                resolvers.first?.();
+              } else if (!secondResponseReceived) {
+                secondResponseReceived = true;
+                resolvers.second?.();
+              }
+            }
+          }
+        })();
+
+        // Wait for first response
+        await Promise.race([
+          firstResponsePromise,
+          new Promise((_, reject) =>
+            setTimeout(
+              () => reject(new Error('Timeout waiting for first response')),
+              15000,
+            ),
+          ),
+        ]);
+
+        expect(firstResponseReceived).toBe(true);
+
+        // Perform control operation: set model
+        await q.setModel('qwen3-vl-plus');
+
+        // Resume the input stream
+        resume();
+
+        // Wait for second response
+        await Promise.race([
+          secondResponsePromise,
+          new Promise((_, reject) =>
+            setTimeout(
+              () => reject(new Error('Timeout waiting for second response')),
+              10000,
+            ),
+          ),
+        ]);
+
+        expect(secondResponseReceived).toBe(true);
+
+        // Verify system messages - model should change from qwen3-max to qwen3-vl-plus
+        expect(systemMessages.length).toBeGreaterThanOrEqual(2);
+        expect(systemMessages[0].model).toBeOneOf(['qwen3-max', 'coder-model']);
+        expect(systemMessages[1].model).toBe('qwen3-vl-plus');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should handle multiple model changes in sequence', async () => {
+      const sessionId = crypto.randomUUID();
+      let resumeResolve1: (() => void) | null = null;
+      let resumeResolve2: (() => void) | null = null;
+      const resumePromise1 = new Promise<void>((resolve) => {
+        resumeResolve1 = resolve;
+      });
+      const resumePromise2 = new Promise<void>((resolve) => {
+        resumeResolve2 = resolve;
+      });
+
+      const generator = (async function* () {
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: { role: 'user', content: 'First message' },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        await resumePromise1;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: { role: 'user', content: 'Second message' },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        await resumePromise2;
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        yield {
+          type: 'user',
+          session_id: sessionId,
+          message: { role: 'user', content: 'Third message' },
+          parent_tool_use_id: null,
+        } as SDKUserMessage;
+      })();
+
+      const q = query({
+        prompt: generator,
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          model: 'qwen3-max',
+          debug: false,
+        },
+      });
+
+      try {
+        const systemMessages: Array<{ model?: string }> = [];
+        let responseCount = 0;
+        const resolvers: Array<() => void> = [];
+        const responsePromises = [
+          new Promise<void>((resolve) => resolvers.push(resolve)),
+          new Promise<void>((resolve) => resolvers.push(resolve)),
+          new Promise<void>((resolve) => resolvers.push(resolve)),
+        ];
+
+        (async () => {
+          for await (const message of q) {
+            if (isSDKSystemMessage(message)) {
+              systemMessages.push({ model: message.model });
+            }
+            if (isSDKAssistantMessage(message)) {
+              if (responseCount < resolvers.length) {
+                resolvers[responseCount]?.();
+                responseCount++;
+              }
+            }
+          }
+        })();
+
+        // Wait for first response
+        await Promise.race([
+          responsePromises[0],
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout 1')), 10000),
+          ),
+        ]);
+
+        // First model change
+        await q.setModel('qwen3-turbo');
+        resumeResolve1!();
+
+        // Wait for second response
+        await Promise.race([
+          responsePromises[1],
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout 2')), 10000),
+          ),
+        ]);
+
+        // Second model change
+        await q.setModel('qwen3-vl-plus');
+        resumeResolve2!();
+
+        // Wait for third response
+        await Promise.race([
+          responsePromises[2],
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout 3')), 10000),
+          ),
+        ]);
+
+        // Verify we received system messages for each model
+        expect(systemMessages.length).toBeGreaterThanOrEqual(3);
+        expect(systemMessages[0].model).toBeOneOf(['qwen3-max', 'coder-model']);
+        expect(systemMessages[1].model).toBe('qwen3-turbo');
+        expect(systemMessages[2].model).toBe('qwen3-vl-plus');
+      } finally {
+        await q.close();
+      }
+    });
+
+    it('should throw error when setModel is called on closed query', async () => {
+      const q = query({
+        prompt: 'Hello',
+        options: {
+          ...SHARED_TEST_OPTIONS,
+          cwd: testDir,
+          model: 'qwen3-max',
+        },
+      });
+
+      await q.close();
+
+      await expect(q.setModel('qwen3-turbo')).rejects.toThrow(
+        'Query is closed',
+      );
+    });
+  });
+});

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

@@ -0,0 +1,970 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * SDK E2E Test Helper
+ * Provides utilities for SDK e2e tests including test isolation,
+ * file management, MCP server setup, and common test utilities.
+ */
+
+import { mkdir, writeFile, readFile, rm, chmod } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import type {
+  SDKMessage,
+  SDKAssistantMessage,
+  SDKSystemMessage,
+  SDKUserMessage,
+  ContentBlock,
+  TextBlock,
+  ToolUseBlock,
+} from '@qwen-code/sdk';
+import {
+  isSDKAssistantMessage,
+  isSDKSystemMessage,
+  isSDKResultMessage,
+} from '@qwen-code/sdk';
+
+// ============================================================================
+// Core Test Helper Class
+// ============================================================================
+
+export interface SDKTestHelperOptions {
+  /**
+   * Optional settings for .qwen/settings.json
+   */
+  settings?: Record<string, unknown>;
+  /**
+   * Whether to create .qwen/settings.json
+   */
+  createQwenConfig?: boolean;
+}
+
+/**
+ * Helper class for SDK E2E tests
+ * Provides isolated test environments for each test case
+ */
+export class SDKTestHelper {
+  testDir: string | null = null;
+  testName?: string;
+  private baseDir: string;
+
+  constructor() {
+    this.baseDir = process.env['E2E_TEST_FILE_DIR']!;
+    if (!this.baseDir) {
+      throw new Error('E2E_TEST_FILE_DIR environment variable not set');
+    }
+  }
+
+  /**
+   * Setup an isolated test directory for a specific test
+   */
+  async setup(
+    testName: string,
+    options: SDKTestHelperOptions = {},
+  ): Promise<string> {
+    this.testName = testName;
+    const sanitizedName = this.sanitizeTestName(testName);
+    this.testDir = join(this.baseDir, sanitizedName);
+
+    await mkdir(this.testDir, { recursive: true });
+
+    // Optionally create .qwen/settings.json for CLI configuration
+    if (options.createQwenConfig) {
+      const qwenDir = join(this.testDir, '.qwen');
+      await mkdir(qwenDir, { recursive: true });
+
+      const settings = {
+        telemetry: {
+          enabled: false, // SDK tests don't need telemetry
+        },
+        ...options.settings,
+      };
+
+      await writeFile(
+        join(qwenDir, 'settings.json'),
+        JSON.stringify(settings, null, 2),
+        'utf-8',
+      );
+    }
+
+    return this.testDir;
+  }
+
+  /**
+   * Create a file in the test directory
+   */
+  async createFile(fileName: string, content: string): Promise<string> {
+    if (!this.testDir) {
+      throw new Error('Test directory not initialized. Call setup() first.');
+    }
+    const filePath = join(this.testDir, fileName);
+    await writeFile(filePath, content, 'utf-8');
+    return filePath;
+  }
+
+  /**
+   * Read a file from the test directory
+   */
+  async readFile(fileName: string): Promise<string> {
+    if (!this.testDir) {
+      throw new Error('Test directory not initialized. Call setup() first.');
+    }
+    const filePath = join(this.testDir, fileName);
+    return await readFile(filePath, 'utf-8');
+  }
+
+  /**
+   * Create a subdirectory in the test directory
+   */
+  async mkdir(dirName: string): Promise<string> {
+    if (!this.testDir) {
+      throw new Error('Test directory not initialized. Call setup() first.');
+    }
+    const dirPath = join(this.testDir, dirName);
+    await mkdir(dirPath, { recursive: true });
+    return dirPath;
+  }
+
+  /**
+   * Check if a file exists in the test directory
+   */
+  fileExists(fileName: string): boolean {
+    if (!this.testDir) {
+      throw new Error('Test directory not initialized. Call setup() first.');
+    }
+    const filePath = join(this.testDir, fileName);
+    return existsSync(filePath);
+  }
+
+  /**
+   * Get the full path to a file in the test directory
+   */
+  getPath(fileName: string): string {
+    if (!this.testDir) {
+      throw new Error('Test directory not initialized. Call setup() first.');
+    }
+    return join(this.testDir, fileName);
+  }
+
+  /**
+   * Cleanup test directory
+   */
+  async cleanup(): Promise<void> {
+    if (this.testDir && process.env['KEEP_OUTPUT'] !== 'true') {
+      try {
+        await rm(this.testDir, { recursive: true, force: true });
+      } catch (error) {
+        if (process.env['VERBOSE'] === 'true') {
+          console.warn('Cleanup warning:', (error as Error).message);
+        }
+      }
+    }
+  }
+
+  /**
+   * Sanitize test name to create valid directory name
+   */
+  private sanitizeTestName(name: string): string {
+    return name
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '-')
+      .replace(/-+/g, '-')
+      .substring(0, 100); // Limit length
+  }
+}
+
+// ============================================================================
+// MCP Server Utilities
+// ============================================================================
+
+export interface MCPServerConfig {
+  command: string;
+  args: string[];
+}
+
+export interface MCPServerResult {
+  scriptPath: string;
+  config: MCPServerConfig;
+}
+
+/**
+ * Built-in MCP server template: Math server with add and multiply tools
+ */
+const MCP_MATH_SERVER_SCRIPT = `#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+
+// Debug logging to stderr (only when MCP_DEBUG or VERBOSE is set)
+const debugEnabled = process.env['MCP_DEBUG'] === 'true' || process.env['VERBOSE'] === 'true';
+function debug(msg) {
+  if (debugEnabled) {
+    fs.writeSync(2, \`[MCP-DEBUG] \${msg}\\n\`);
+  }
+}
+
+debug('MCP server starting...');
+
+// Simple JSON-RPC implementation for MCP
+class SimpleJSONRPC {
+  constructor() {
+    this.handlers = new Map();
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    
+    this.rl.on('line', (line) => {
+      debug(\`Received line: \${line}\`);
+      try {
+        const message = JSON.parse(line);
+        debug(\`Parsed message: \${JSON.stringify(message)}\`);
+        this.handleMessage(message);
+      } catch (e) {
+        debug(\`Parse error: \${e.message}\`);
+      }
+    });
+  }
+  
+  send(message) {
+    const msgStr = JSON.stringify(message);
+    debug(\`Sending message: \${msgStr}\`);
+    process.stdout.write(msgStr + '\\n');
+  }
+  
+  async handleMessage(message) {
+    if (message.method && this.handlers.has(message.method)) {
+      try {
+        const result = await this.handlers.get(message.method)(message.params || {});
+        if (message.id !== undefined) {
+          this.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            result
+          });
+        }
+      } catch (error) {
+        if (message.id !== undefined) {
+          this.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error.message
+            }
+          });
+        }
+      }
+    } else if (message.id !== undefined) {
+      this.send({
+        jsonrpc: '2.0',
+        id: message.id,
+        error: {
+          code: -32601,
+          message: 'Method not found'
+        }
+      });
+    }
+  }
+  
+  on(method, handler) {
+    this.handlers.set(method, handler);
+  }
+}
+
+// Create MCP server
+const rpc = new SimpleJSONRPC();
+
+// Handle initialize
+rpc.on('initialize', async (params) => {
+  debug('Handling initialize request');
+  return {
+    protocolVersion: '2024-11-05',
+    capabilities: {
+      tools: {}
+    },
+    serverInfo: {
+      name: 'test-math-server',
+      version: '1.0.0'
+    }
+  };
+});
+
+// Handle tools/list
+rpc.on('tools/list', async () => {
+  debug('Handling tools/list request');
+  return {
+    tools: [
+      {
+        name: 'add',
+        description: 'Add two numbers together',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            a: { type: 'number', description: 'First number' },
+            b: { type: 'number', description: 'Second number' }
+          },
+          required: ['a', 'b']
+        }
+      },
+      {
+        name: 'multiply',
+        description: 'Multiply two numbers together',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            a: { type: 'number', description: 'First number' },
+            b: { type: 'number', description: 'Second number' }
+          },
+          required: ['a', 'b']
+        }
+      }
+    ]
+  };
+});
+
+// Handle tools/call
+rpc.on('tools/call', async (params) => {
+  debug(\`Handling tools/call request for tool: \${params.name}\`);
+  
+  if (params.name === 'add') {
+    const { a, b } = params.arguments;
+    return {
+      content: [{
+        type: 'text',
+        text: String(a + b)
+      }]
+    };
+  }
+  
+  if (params.name === 'multiply') {
+    const { a, b } = params.arguments;
+    return {
+      content: [{
+        type: 'text',
+        text: String(a * b)
+      }]
+    };
+  }
+  
+  throw new Error('Unknown tool: ' + params.name);
+});
+
+// Send initialization notification
+rpc.send({
+  jsonrpc: '2.0',
+  method: 'initialized'
+});
+`;
+
+/**
+ * Create an MCP server script in the test directory
+ * @param helper - SDKTestHelper instance
+ * @param type - Type of MCP server ('math' or provide custom script)
+ * @param serverName - Name of the MCP server (default: 'test-math-server')
+ * @param customScript - Custom MCP server script (if type is not 'math')
+ * @returns Object with scriptPath and config
+ */
+export async function createMCPServer(
+  helper: SDKTestHelper,
+  type: 'math' | 'custom' = 'math',
+  serverName: string = 'test-math-server',
+  customScript?: string,
+): Promise<MCPServerResult> {
+  if (!helper.testDir) {
+    throw new Error('Test directory not initialized. Call setup() first.');
+  }
+
+  const script = type === 'math' ? MCP_MATH_SERVER_SCRIPT : customScript;
+  if (!script) {
+    throw new Error('Custom script required when type is "custom"');
+  }
+
+  const scriptPath = join(helper.testDir, `${serverName}.cjs`);
+  await writeFile(scriptPath, script, 'utf-8');
+
+  // Make script executable on Unix-like systems
+  if (process.platform !== 'win32') {
+    await chmod(scriptPath, 0o755);
+  }
+
+  return {
+    scriptPath,
+    config: {
+      command: 'node',
+      args: [scriptPath],
+    },
+  };
+}
+
+// ============================================================================
+// Message & Content Utilities
+// ============================================================================
+
+/**
+ * Extract text from ContentBlock array
+ */
+export function extractText(content: ContentBlock[]): string {
+  return content
+    .filter((block): block is TextBlock => block.type === 'text')
+    .map((block) => block.text)
+    .join('');
+}
+
+/**
+ * Collect messages by type
+ */
+export function collectMessagesByType<T extends SDKMessage>(
+  messages: SDKMessage[],
+  predicate: (msg: SDKMessage) => msg is T,
+): T[] {
+  return messages.filter(predicate);
+}
+
+/**
+ * Find tool use blocks in a message
+ */
+export function findToolUseBlocks(
+  message: SDKAssistantMessage,
+  toolName?: string,
+): ToolUseBlock[] {
+  const toolUseBlocks = message.message.content.filter(
+    (block): block is ToolUseBlock => block.type === 'tool_use',
+  );
+
+  if (toolName) {
+    return toolUseBlocks.filter((block) => block.name === toolName);
+  }
+
+  return toolUseBlocks;
+}
+
+/**
+ * Extract all assistant text from messages
+ */
+export function getAssistantText(messages: SDKMessage[]): string {
+  return messages
+    .filter(isSDKAssistantMessage)
+    .map((msg) => extractText(msg.message.content))
+    .join('');
+}
+
+/**
+ * Find system message with optional subtype filter
+ */
+export function findSystemMessage(
+  messages: SDKMessage[],
+  subtype?: string,
+): SDKSystemMessage | null {
+  const systemMessages = messages.filter(isSDKSystemMessage);
+
+  if (subtype) {
+    return systemMessages.find((msg) => msg.subtype === subtype) || null;
+  }
+
+  return systemMessages[0] || null;
+}
+
+/**
+ * Find all tool calls in messages
+ */
+export function findToolCalls(
+  messages: SDKMessage[],
+  toolName?: string,
+): Array<{ message: SDKAssistantMessage; toolUse: ToolUseBlock }> {
+  const results: Array<{
+    message: SDKAssistantMessage;
+    toolUse: ToolUseBlock;
+  }> = [];
+
+  for (const message of messages) {
+    if (isSDKAssistantMessage(message)) {
+      const toolUseBlocks = findToolUseBlocks(message, toolName);
+      for (const toolUse of toolUseBlocks) {
+        results.push({ message, toolUse });
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Find tool result for a specific tool use ID
+ */
+export function findToolResult(
+  messages: SDKMessage[],
+  toolUseId: string,
+): { content: string; isError: boolean } | null {
+  for (const message of messages) {
+    if (message.type === 'user' && 'message' in message) {
+      const userMsg = message as SDKUserMessage;
+      const content = userMsg.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (
+            block.type === 'tool_result' &&
+            (block as { tool_use_id?: string }).tool_use_id === toolUseId
+          ) {
+            const resultBlock = block as {
+              content?: string | ContentBlock[];
+              is_error?: boolean;
+            };
+            let resultContent = '';
+            if (typeof resultBlock.content === 'string') {
+              resultContent = resultBlock.content;
+            } else if (Array.isArray(resultBlock.content)) {
+              resultContent = resultBlock.content
+                .filter((b): b is TextBlock => b.type === 'text')
+                .map((b) => b.text)
+                .join('');
+            }
+            return {
+              content: resultContent,
+              isError: resultBlock.is_error ?? false,
+            };
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Find all tool results for a specific tool name
+ */
+export function findToolResults(
+  messages: SDKMessage[],
+  toolName: string,
+): Array<{ toolUseId: string; content: string; isError: boolean }> {
+  const results: Array<{
+    toolUseId: string;
+    content: string;
+    isError: boolean;
+  }> = [];
+
+  // First find all tool calls for this tool
+  const toolCalls = findToolCalls(messages, toolName);
+
+  // Then find the result for each tool call
+  for (const { toolUse } of toolCalls) {
+    const result = findToolResult(messages, toolUse.id);
+    if (result) {
+      results.push({
+        toolUseId: toolUse.id,
+        content: result.content,
+        isError: result.isError,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Find all tool result blocks from messages (without requiring tool name)
+ */
+export function findAllToolResultBlocks(
+  messages: SDKMessage[],
+): Array<{ toolUseId: string; content: string; isError: boolean }> {
+  const results: Array<{
+    toolUseId: string;
+    content: string;
+    isError: boolean;
+  }> = [];
+
+  for (const message of messages) {
+    if (message.type === 'user' && 'message' in message) {
+      const userMsg = message as SDKUserMessage;
+      const content = userMsg.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'tool_result' && 'tool_use_id' in block) {
+            const resultBlock = block as {
+              tool_use_id: string;
+              content?: string | ContentBlock[];
+              is_error?: boolean;
+            };
+            let resultContent = '';
+            if (typeof resultBlock.content === 'string') {
+              resultContent = resultBlock.content;
+            } else if (Array.isArray(resultBlock.content)) {
+              resultContent = (resultBlock.content as ContentBlock[])
+                .filter((b): b is TextBlock => b.type === 'text')
+                .map((b) => b.text)
+                .join('');
+            }
+            results.push({
+              toolUseId: resultBlock.tool_use_id,
+              content: resultContent,
+              isError: resultBlock.is_error ?? false,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check if any tool results exist in messages
+ */
+export function hasAnyToolResults(messages: SDKMessage[]): boolean {
+  return findAllToolResultBlocks(messages).length > 0;
+}
+
+/**
+ * Check if any successful (non-error) tool results exist
+ */
+export function hasSuccessfulToolResults(messages: SDKMessage[]): boolean {
+  return findAllToolResultBlocks(messages).some((r) => !r.isError);
+}
+
+/**
+ * Check if any error tool results exist
+ */
+export function hasErrorToolResults(messages: SDKMessage[]): boolean {
+  return findAllToolResultBlocks(messages).some((r) => r.isError);
+}
+
+// ============================================================================
+// Streaming Input Utilities
+// ============================================================================
+
+/**
+ * Create a simple streaming input from an array of message contents
+ */
+export async function* createStreamingInput(
+  messageContents: string[],
+  sessionId?: string,
+): AsyncIterable<SDKUserMessage> {
+  const sid = sessionId || crypto.randomUUID();
+
+  for (const content of messageContents) {
+    yield {
+      type: 'user',
+      session_id: sid,
+      message: {
+        role: 'user',
+        content: content,
+      },
+      parent_tool_use_id: null,
+    } as SDKUserMessage;
+
+    // Small delay between messages
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+
+/**
+ * Create a controlled streaming input with pause/resume capability
+ */
+export function createControlledStreamingInput(
+  messageContents: string[],
+  sessionId?: string,
+): {
+  generator: AsyncIterable<SDKUserMessage>;
+  resume: () => void;
+  resumeAll: () => void;
+} {
+  const sid = sessionId || crypto.randomUUID();
+  const resumeResolvers: Array<() => void> = [];
+  const resumePromises: Array<Promise<void>> = [];
+
+  // Create a resume promise for each message after the first
+  for (let i = 1; i < messageContents.length; i++) {
+    const promise = new Promise<void>((resolve) => {
+      resumeResolvers.push(resolve);
+    });
+    resumePromises.push(promise);
+  }
+
+  const generator = (async function* () {
+    // Yield first message immediately
+    yield {
+      type: 'user',
+      session_id: sid,
+      message: {
+        role: 'user',
+        content: messageContents[0],
+      },
+      parent_tool_use_id: null,
+    } as SDKUserMessage;
+
+    // For subsequent messages, wait for resume
+    for (let i = 1; i < messageContents.length; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      await resumePromises[i - 1];
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      yield {
+        type: 'user',
+        session_id: sid,
+        message: {
+          role: 'user',
+          content: messageContents[i],
+        },
+        parent_tool_use_id: null,
+      } as SDKUserMessage;
+    }
+  })();
+
+  let currentResumeIndex = 0;
+
+  return {
+    generator,
+    resume: () => {
+      if (currentResumeIndex < resumeResolvers.length) {
+        resumeResolvers[currentResumeIndex]();
+        currentResumeIndex++;
+      }
+    },
+    resumeAll: () => {
+      resumeResolvers.forEach((resolve) => resolve());
+      currentResumeIndex = resumeResolvers.length;
+    },
+  };
+}
+
+// ============================================================================
+// Assertion Utilities
+// ============================================================================
+
+/**
+ * Assert that messages follow expected type sequence
+ */
+export function assertMessageSequence(
+  messages: SDKMessage[],
+  expectedTypes: string[],
+): void {
+  const actualTypes = messages.map((msg) => msg.type);
+
+  if (actualTypes.length < expectedTypes.length) {
+    throw new Error(
+      `Expected at least ${expectedTypes.length} messages, got ${actualTypes.length}`,
+    );
+  }
+
+  for (let i = 0; i < expectedTypes.length; i++) {
+    if (actualTypes[i] !== expectedTypes[i]) {
+      throw new Error(
+        `Expected message ${i} to be type '${expectedTypes[i]}', got '${actualTypes[i]}'`,
+      );
+    }
+  }
+}
+
+/**
+ * Assert that a specific tool was called
+ */
+export function assertToolCalled(
+  messages: SDKMessage[],
+  toolName: string,
+): void {
+  const toolCalls = findToolCalls(messages, toolName);
+
+  if (toolCalls.length === 0) {
+    const allToolCalls = findToolCalls(messages);
+    const allToolNames = allToolCalls.map((tc) => tc.toolUse.name);
+    throw new Error(
+      `Expected tool '${toolName}' to be called. Found tools: ${allToolNames.length > 0 ? allToolNames.join(', ') : 'none'}`,
+    );
+  }
+}
+
+/**
+ * Assert that the conversation completed successfully
+ */
+export function assertSuccessfulCompletion(messages: SDKMessage[]): void {
+  const lastMessage = messages[messages.length - 1];
+
+  if (!isSDKResultMessage(lastMessage)) {
+    throw new Error(
+      `Expected last message to be a result message, got '${lastMessage.type}'`,
+    );
+  }
+
+  if (lastMessage.subtype !== 'success') {
+    throw new Error(
+      `Expected successful completion, got result subtype '${lastMessage.subtype}'`,
+    );
+  }
+}
+
+/**
+ * Wait for a condition to be true with timeout
+ */
+export async function waitFor(
+  predicate: () => boolean | Promise<boolean>,
+  options: {
+    timeout?: number;
+    interval?: number;
+    errorMessage?: string;
+  } = {},
+): Promise<void> {
+  const {
+    timeout = 5000,
+    interval = 100,
+    errorMessage = 'Condition not met within timeout',
+  } = options;
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    const result = await predicate();
+    if (result) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+
+  throw new Error(errorMessage);
+}
+
+// ============================================================================
+// Debug and Validation Utilities
+// ============================================================================
+
+/**
+ * Validate model output and warn about unexpected content
+ * Inspired by integration-tests test-helper
+ */
+export function validateModelOutput(
+  result: string,
+  expectedContent: string | (string | RegExp)[] | null = null,
+  testName = '',
+): boolean {
+  // First, check if there's any output at all
+  if (!result || result.trim().length === 0) {
+    throw new Error('Expected model to return some output');
+  }
+
+  // If expectedContent is provided, check for it and warn if missing
+  if (expectedContent) {
+    const contents = Array.isArray(expectedContent)
+      ? expectedContent
+      : [expectedContent];
+    const missingContent = contents.filter((content) => {
+      if (typeof content === 'string') {
+        return !result.toLowerCase().includes(content.toLowerCase());
+      } else if (content instanceof RegExp) {
+        return !content.test(result);
+      }
+      return false;
+    });
+
+    if (missingContent.length > 0) {
+      console.warn(
+        `Warning: Model did not include expected content in response: ${missingContent.join(', ')}.`,
+        'This is not ideal but not a test failure.',
+      );
+      console.warn(
+        'The tool was called successfully, which is the main requirement.',
+      );
+      return false;
+    } else if (process.env['VERBOSE'] === 'true') {
+      console.log(`${testName}: Model output validated successfully.`);
+    }
+    return true;
+  }
+
+  return true;
+}
+
+/**
+ * Print debug information when tests fail
+ */
+export function printDebugInfo(
+  messages: SDKMessage[],
+  context: Record<string, unknown> = {},
+): void {
+  console.error('Test failed - Debug info:');
+  console.error('Message count:', messages.length);
+
+  // Print message types
+  const messageTypes = messages.map((m) => m.type);
+  console.error('Message types:', messageTypes.join(', '));
+
+  // Print assistant text
+  const assistantText = getAssistantText(messages);
+  console.error(
+    'Assistant text (first 500 chars):',
+    assistantText.substring(0, 500),
+  );
+  if (assistantText.length > 500) {
+    console.error(
+      'Assistant text (last 500 chars):',
+      assistantText.substring(assistantText.length - 500),
+    );
+  }
+
+  // Print tool calls
+  const toolCalls = findToolCalls(messages);
+  console.error(
+    'Tool calls found:',
+    toolCalls.map((tc) => tc.toolUse.name),
+  );
+
+  // Print any additional context provided
+  Object.entries(context).forEach(([key, value]) => {
+    console.error(`${key}:`, value);
+  });
+}
+
+/**
+ * Create detailed error message for tool call expectations
+ */
+export function createToolCallErrorMessage(
+  expectedTools: string | string[],
+  foundTools: string[],
+  messages: SDKMessage[],
+): string {
+  const expectedStr = Array.isArray(expectedTools)
+    ? expectedTools.join(' or ')
+    : expectedTools;
+
+  const assistantText = getAssistantText(messages);
+  const preview = assistantText
+    ? assistantText.substring(0, 200) + '...'
+    : 'no output';
+
+  return (
+    `Expected to find ${expectedStr} tool call(s). ` +
+    `Found: ${foundTools.length > 0 ? foundTools.join(', ') : 'none'}. ` +
+    `Output preview: ${preview}`
+  );
+}
+
+// ============================================================================
+// Shared Test Options Helper
+// ============================================================================
+
+/**
+ * Create shared test options with CLI path
+ */
+export function createSharedTestOptions(
+  overrides: Record<string, unknown> = {},
+) {
+  const TEST_CLI_PATH = process.env['TEST_CLI_PATH'];
+  if (!TEST_CLI_PATH) {
+    throw new Error('TEST_CLI_PATH environment variable not set');
+  }
+
+  return {
+    pathToQwenExecutable: TEST_CLI_PATH,
+    ...overrides,
+  };
+}

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

@@ -0,0 +1,744 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * E2E tests for tool control parameters:
+ * - coreTools: Limit available tools to a specific set
+ * - excludeTools: Block specific tools from execution
+ * - allowedTools: Auto-approve specific tools without confirmation
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { query, isSDKAssistantMessage, type SDKMessage } from '@qwen-code/sdk';
+import {
+  SDKTestHelper,
+  extractText,
+  findToolCalls,
+  findToolResults,
+  assertSuccessfulCompletion,
+  createSharedTestOptions,
+} from './test-helper.js';
+
+const SHARED_TEST_OPTIONS = createSharedTestOptions();
+const TEST_TIMEOUT = 60000;
+
+describe('Tool Control Parameters (E2E)', () => {
+  let helper: SDKTestHelper;
+  let testDir: string;
+
+  beforeEach(async () => {
+    helper = new SDKTestHelper();
+    testDir = await helper.setup('tool-control', {
+      createQwenConfig: false,
+    });
+  });
+
+  afterEach(async () => {
+    await helper.cleanup();
+  });
+
+  describe('coreTools parameter', () => {
+    it(
+      'should only allow specified tools when coreTools is set',
+      async () => {
+        // Create a test file
+        await helper.createFile('test.txt', 'original content');
+
+        const q = query({
+          prompt:
+            'Read the file test.txt and then write "modified" to test.txt. Finally, list the directory.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Only allow read_file and write_file, exclude list_directory
+            coreTools: ['read_file', 'write_file'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          // Should have read_file and write_file calls
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+
+          // Should NOT have list_directory since it's not in coreTools
+          expect(toolNames).not.toContain('list_directory');
+
+          // Verify file was modified
+          const content = await helper.readFile('test.txt');
+          expect(content).toContain('modified');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should work with minimal tool set',
+      async () => {
+        const q = query({
+          prompt: 'What is 2 + 2? Just answer with the number.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            // Only allow thinking, no file operations
+            coreTools: [],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+        let assistantText = '';
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+
+            if (isSDKAssistantMessage(message)) {
+              assistantText += extractText(message.message.content);
+            }
+          }
+
+          // Should answer without any tool calls
+          expect(assistantText).toMatch(/4/);
+
+          // Should have no tool calls
+          const toolCalls = findToolCalls(messages);
+          expect(toolCalls.length).toBe(0);
+
+          assertSuccessfulCompletion(messages);
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+  });
+
+  describe('excludeTools parameter', () => {
+    it(
+      'should block excluded tools from execution',
+      async () => {
+        await helper.createFile('test.txt', 'test content');
+
+        const q = query({
+          prompt:
+            'Read test.txt and then write empty content to it to clear it.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            coreTools: ['read_file', 'write_file'],
+            // Block all write_file tool
+            excludeTools: ['write_file'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should be able to read the file
+          expect(toolNames).toContain('read_file');
+
+          // The excluded tools should have been called but returned permission declined
+          // Check if write_file was attempted and got permission denied
+          const writeFileResults = findToolResults(messages, 'write_file');
+          if (writeFileResults.length > 0) {
+            // Tool was called but should have permission declined message
+            for (const result of writeFileResults) {
+              expect(result.content).toMatch(/permission.*declined/i);
+            }
+          }
+
+          // File content should remain unchanged (because write was denied)
+          const content = await helper.readFile('test.txt');
+          expect(content).toBe('test content');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should block multiple excluded tools',
+      async () => {
+        await helper.createFile('test.txt', 'test content');
+
+        const q = query({
+          prompt: 'Read test.txt, list the directory, and run "echo hello".',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Block multiple tools
+            excludeTools: ['list_directory', 'run_shell_command'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should be able to read
+          expect(toolNames).toContain('read_file');
+
+          // Excluded tools should have been attempted but returned permission declined
+          const listDirResults = findToolResults(messages, 'list_directory');
+          if (listDirResults.length > 0) {
+            for (const result of listDirResults) {
+              expect(result.content).toMatch(/permission.*declined/i);
+            }
+          }
+
+          const shellResults = findToolResults(messages, 'run_shell_command');
+          if (shellResults.length > 0) {
+            for (const result of shellResults) {
+              expect(result.content).toMatch(/permission.*declined/i);
+            }
+          }
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should block all shell commands when run_shell_command is excluded',
+      async () => {
+        const q = query({
+          prompt: 'Run "echo hello" and "ls -la" commands.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Block all shell commands - excludeTools blocks entire tools
+            excludeTools: ['run_shell_command'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          // All shell commands should have permission declined
+          const shellResults = findToolResults(messages, 'run_shell_command');
+          for (const result of shellResults) {
+            expect(result.content).toMatch(/permission.*declined/i);
+          }
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'excludeTools should take priority over allowedTools',
+      async () => {
+        await helper.createFile('test.txt', 'test content');
+
+        const q = query({
+          prompt:
+            'Clear the content of test.txt by writing empty string to it.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            // Conflicting settings: exclude takes priority
+            excludeTools: ['write_file'],
+            allowedTools: ['write_file'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          // write_file should have been attempted but returned permission declined
+          const writeFileResults = findToolResults(messages, 'write_file');
+          if (writeFileResults.length > 0) {
+            // Tool was called but should have permission declined message (exclude takes priority)
+            for (const result of writeFileResults) {
+              expect(result.content).toMatch(/permission.*declined/i);
+            }
+          }
+
+          // File content should remain unchanged (because write was denied)
+          const content = await helper.readFile('test.txt');
+          expect(content).toBe('test content');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+  });
+
+  describe('allowedTools parameter', () => {
+    it(
+      'should auto-approve allowed tools without canUseTool callback',
+      async () => {
+        await helper.createFile('test.txt', 'original');
+
+        let canUseToolCalled = false;
+
+        const q = query({
+          prompt: 'Read test.txt and write "modified" to it.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            coreTools: ['read_file', 'write_file'],
+            // Allow write_file without confirmation
+            allowedTools: ['read_file', 'write_file'],
+            canUseTool: async (_toolName) => {
+              canUseToolCalled = true;
+              return { behavior: 'deny', message: 'Should not be called' };
+            },
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should have executed the tools
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+
+          // canUseTool should NOT have been called (tools are in allowedTools)
+          expect(canUseToolCalled).toBe(false);
+
+          // Verify file was modified
+          const content = await helper.readFile('test.txt');
+          expect(content).toContain('modified');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should allow specific shell commands with pattern matching',
+      async () => {
+        const q = query({
+          prompt: 'Run "echo hello" and "ls -la" commands.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            // Allow specific shell commands
+            allowedTools: ['ShellTool(echo )', 'ShellTool(ls )'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const shellCalls = toolCalls.filter(
+            (tc) => tc.toolUse.name === 'run_shell_command',
+          );
+
+          // Should have executed shell commands
+          expect(shellCalls.length).toBeGreaterThan(0);
+
+          // All shell commands should be echo or ls
+          for (const call of shellCalls) {
+            const input = call.toolUse.input as { command?: string };
+            if (input.command) {
+              expect(input.command).toMatch(/^(echo |ls )/);
+            }
+          }
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should fall back to canUseTool for non-allowed tools',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const canUseToolCalls: string[] = [];
+
+        const q = query({
+          prompt: 'Read test.txt and append an empty line to it.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            // Only allow read_file, list_directory should trigger canUseTool
+            coreTools: ['read_file', 'write_file'],
+            allowedTools: ['read_file'],
+            canUseTool: async (toolName) => {
+              canUseToolCalls.push(toolName);
+              return {
+                behavior: 'allow',
+                updatedInput: {},
+              };
+            },
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Both tools should have been executed
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+
+          // canUseTool should have been called for write_file (not in allowedTools)
+          // but NOT for read_file (in allowedTools)
+          expect(canUseToolCalls).toContain('write_file');
+          expect(canUseToolCalls).not.toContain('read_file');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should work with permissionMode: auto-edit',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const canUseToolCalls: string[] = [];
+
+        const q = query({
+          prompt: 'Read test.txt, write "new" to it, and list the directory.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'auto-edit',
+            // Allow list_directory in addition to auto-approved edit tools
+            allowedTools: ['list_directory'],
+            canUseTool: async (toolName) => {
+              canUseToolCalls.push(toolName);
+              return {
+                behavior: 'deny',
+                message: 'Should not be called',
+              };
+            },
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // All tools should have been executed
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+          expect(toolNames).toContain('list_directory');
+
+          // canUseTool should NOT have been called
+          // (edit tools auto-approved, list_directory in allowedTools)
+          expect(canUseToolCalls.length).toBe(0);
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+  });
+
+  describe('Combined tool control scenarios', () => {
+    it(
+      'should work with coreTools + allowedTools',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const q = query({
+          prompt: 'Read test.txt and write "modified" to it.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            // Limit to specific tools
+            coreTools: ['read_file', 'write_file', 'list_directory'],
+            // Auto-approve write operations
+            allowedTools: ['write_file'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should use allowed tools from coreTools
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+
+          // Should NOT use tools outside coreTools
+          expect(toolNames).not.toContain('run_shell_command');
+
+          // Verify file was modified
+          const content = await helper.readFile('test.txt');
+          expect(content).toContain('modified');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should work with coreTools + excludeTools',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const q = query({
+          prompt:
+            'Read test.txt, write "new content" to it, and list directory.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Allow file operations
+            coreTools: ['read_file', 'write_file', 'edit', 'list_directory'],
+            // But exclude edit
+            excludeTools: ['edit'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should use non-excluded tools from coreTools
+          expect(toolNames).toContain('read_file');
+
+          // Should NOT use excluded tool
+          expect(toolNames).not.toContain('edit');
+
+          // File should still exist
+          expect(helper.fileExists('test.txt')).toBe(true);
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should work with all three parameters together',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const canUseToolCalls: string[] = [];
+
+        const q = query({
+          prompt:
+            'Read test.txt, write "modified" to it, and list the directory.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'default',
+            // Limit available tools
+            coreTools: ['read_file', 'write_file', 'list_directory', 'edit'],
+            // Block edit
+            excludeTools: ['edit'],
+            // Auto-approve write
+            allowedTools: ['write_file'],
+            canUseTool: async (toolName) => {
+              canUseToolCalls.push(toolName);
+              return {
+                behavior: 'allow',
+                updatedInput: {},
+              };
+            },
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should use allowed tools
+          expect(toolNames).toContain('read_file');
+          expect(toolNames).toContain('write_file');
+
+          // Should NOT use excluded tool
+          expect(toolNames).not.toContain('edit');
+
+          // canUseTool should be called for tools not in allowedTools
+          // but should NOT be called for write_file (in allowedTools)
+          expect(canUseToolCalls).not.toContain('write_file');
+
+          // Verify file was modified
+          const content = await helper.readFile('test.txt');
+          expect(content).toContain('modified');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+  });
+
+  describe('Edge cases and error handling', () => {
+    it(
+      'should handle non-existent tool names in excludeTools',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const q = query({
+          prompt: 'Read test.txt.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Non-existent tool names should be ignored
+            excludeTools: ['non_existent_tool', 'another_fake_tool'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should work normally
+          expect(toolNames).toContain('read_file');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+
+    it(
+      'should handle non-existent tool names in allowedTools',
+      async () => {
+        await helper.createFile('test.txt', 'test');
+
+        const q = query({
+          prompt: 'Read test.txt.',
+          options: {
+            ...SHARED_TEST_OPTIONS,
+            cwd: testDir,
+            permissionMode: 'yolo',
+            // Non-existent tool names should be ignored
+            allowedTools: ['non_existent_tool', 'read_file'],
+            debug: false,
+          },
+        });
+
+        const messages: SDKMessage[] = [];
+
+        try {
+          for await (const message of q) {
+            messages.push(message);
+          }
+
+          const toolCalls = findToolCalls(messages);
+          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
+
+          // Should work normally
+          expect(toolNames).toContain('read_file');
+        } finally {
+          await q.close();
+        }
+      },
+      TEST_TIMEOUT,
+    );
+  });
+});

integration-tests/simple-mcp-server.test.ts

@@ -213,7 +213,7 @@ describe('simple-mcp-server', () => {
   it('should add two numbers', async () => {
     // Test directory is already set up in before hook
     // Just run the command - MCP server config is in settings.json
-    const output = await rig.run('add 5 and 10');
+    const output = await rig.run('add 5 and 10, use tool if you can.');
 
     const foundToolCall = await rig.waitForToolCall('add');
 

integration-tests/tsconfig.json

@@ -2,7 +2,11 @@
   "extends": "../tsconfig.json",
   "compilerOptions": {
     "noEmit": true,
-    "allowJs": true
+    "allowJs": true,
+    "baseUrl": ".",
+    "paths": {
+      "@qwen-code/sdk": ["../packages/sdk-typescript/dist/index.d.ts"]
+    }
   },
   "include": ["**/*.ts"],
   "references": [{ "path": "../packages/core" }]

integration-tests/vitest.config.ts

@@ -1,12 +1,15 @@
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 
 import { defineConfig } from 'vitest/config';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const timeoutMinutes = Number(process.env.TB_TIMEOUT_MINUTES || '5');
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const timeoutMinutes = Number(process.env['TB_TIMEOUT_MINUTES'] || '5');
 const testTimeoutMs = timeoutMinutes * 60 * 1000;
 
 export default defineConfig({
@@ -25,4 +28,13 @@ export default defineConfig({
       },
     },
   },
+  resolve: {
+    alias: {
+      // Use built SDK bundle for e2e tests
+      '@qwen-code/sdk': resolve(
+        __dirname,
+        '../packages/sdk-typescript/dist/index.mjs',
+      ),
+    },
+  },
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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.3.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
   },
   "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.3.0",
+  "version": "0.4.0",
   "description": "Qwen Code",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.3.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
   },
   "dependencies": {
     "@google/genai": "1.16.0",

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

@@ -42,6 +42,14 @@ export class AgentSideConnection implements Client {
           const validatedParams = schema.loadSessionRequestSchema.parse(params);
           return agent.loadSession(validatedParams);
         }
+        case schema.AGENT_METHODS.session_list: {
+          if (!agent.listSessions) {
+            throw RequestError.methodNotFound();
+          }
+          const validatedParams =
+            schema.listSessionsRequestSchema.parse(params);
+          return agent.listSessions(validatedParams);
+        }
         case schema.AGENT_METHODS.authenticate: {
           const validatedParams =
             schema.authenticateRequestSchema.parse(params);
@@ -55,6 +63,13 @@ export class AgentSideConnection implements Client {
           const validatedParams = schema.cancelNotificationSchema.parse(params);
           return agent.cancel(validatedParams);
         }
+        case schema.AGENT_METHODS.session_set_mode: {
+          if (!agent.setMode) {
+            throw RequestError.methodNotFound();
+          }
+          const validatedParams = schema.setModeRequestSchema.parse(params);
+          return agent.setMode(validatedParams);
+        }
         default:
           throw RequestError.methodNotFound(method);
       }
@@ -360,7 +375,11 @@ export interface Agent {
   loadSession?(
     params: schema.LoadSessionRequest,
   ): Promise<schema.LoadSessionResponse>;
+  listSessions?(
+    params: schema.ListSessionsRequest,
+  ): Promise<schema.ListSessionsResponse>;
   authenticate(params: schema.AuthenticateRequest): Promise<void>;
   prompt(params: schema.PromptRequest): Promise<schema.PromptResponse>;
   cancel(params: schema.CancelNotification): Promise<void>;
+  setMode?(params: schema.SetModeRequest): Promise<schema.SetModeResponse>;
 }

packages/cli/src/acp-integration/acpAgent.ts

@@ -0,0 +1,329 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { ReadableStream, WritableStream } from 'node:stream/web';
+
+import type { Config, ConversationRecord } from '@qwen-code/qwen-code-core';
+import {
+  APPROVAL_MODE_INFO,
+  APPROVAL_MODES,
+  AuthType,
+  clearCachedCredentialFile,
+  MCPServerConfig,
+  SessionService,
+  buildApiHistoryFromConversation,
+} from '@qwen-code/qwen-code-core';
+import type { ApprovalModeValue } from './schema.js';
+import * as acp from './acp.js';
+import { AcpFileSystemService } from './service/filesystem.js';
+import { Readable, Writable } from 'node:stream';
+import type { LoadedSettings } from '../config/settings.js';
+import { SettingScope } from '../config/settings.js';
+import { z } from 'zod';
+import { ExtensionStorage, type Extension } from '../config/extension.js';
+import type { CliArgs } from '../config/config.js';
+import { loadCliConfig } from '../config/config.js';
+import { ExtensionEnablementManager } from '../config/extensions/extensionEnablement.js';
+
+// Import the modular Session class
+import { Session } from './session/Session.js';
+
+export async function runAcpAgent(
+  config: Config,
+  settings: LoadedSettings,
+  extensions: Extension[],
+  argv: CliArgs,
+) {
+  const stdout = Writable.toWeb(process.stdout) as WritableStream;
+  const stdin = Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;
+
+  // Stdout is used to send messages to the client, so console.log/console.info
+  // messages to stderr so that they don't interfere with ACP.
+  console.log = console.error;
+  console.info = console.error;
+  console.debug = console.error;
+
+  new acp.AgentSideConnection(
+    (client: acp.Client) =>
+      new GeminiAgent(config, settings, extensions, argv, client),
+    stdout,
+    stdin,
+  );
+}
+
+class GeminiAgent {
+  private sessions: Map<string, Session> = new Map();
+  private clientCapabilities: acp.ClientCapabilities | undefined;
+
+  constructor(
+    private config: Config,
+    private settings: LoadedSettings,
+    private extensions: Extension[],
+    private argv: CliArgs,
+    private client: acp.Client,
+  ) {}
+
+  async initialize(
+    args: acp.InitializeRequest,
+  ): Promise<acp.InitializeResponse> {
+    this.clientCapabilities = args.clientCapabilities;
+    const authMethods = [
+      {
+        id: AuthType.USE_OPENAI,
+        name: 'Use OpenAI API key',
+        description:
+          'Requires setting the `OPENAI_API_KEY` environment variable',
+      },
+      {
+        id: AuthType.QWEN_OAUTH,
+        name: 'Qwen OAuth',
+        description:
+          'OAuth authentication for Qwen models with 2000 daily requests',
+      },
+    ];
+
+    // Get current approval mode from config
+    const currentApprovalMode = this.config.getApprovalMode();
+
+    // Build available modes from shared APPROVAL_MODE_INFO
+    const availableModes = APPROVAL_MODES.map((mode) => ({
+      id: mode as ApprovalModeValue,
+      name: APPROVAL_MODE_INFO[mode].name,
+      description: APPROVAL_MODE_INFO[mode].description,
+    }));
+
+    const version = process.env['CLI_VERSION'] || process.version;
+
+    return {
+      protocolVersion: acp.PROTOCOL_VERSION,
+      agentInfo: {
+        name: 'qwen-code',
+        title: 'Qwen Code',
+        version,
+      },
+      authMethods,
+      modes: {
+        currentModeId: currentApprovalMode as ApprovalModeValue,
+        availableModes,
+      },
+      agentCapabilities: {
+        loadSession: true,
+        promptCapabilities: {
+          image: true,
+          audio: true,
+          embeddedContext: true,
+        },
+      },
+    };
+  }
+
+  async authenticate({ methodId }: acp.AuthenticateRequest): Promise<void> {
+    const method = z.nativeEnum(AuthType).parse(methodId);
+
+    await clearCachedCredentialFile();
+    await this.config.refreshAuth(method);
+    this.settings.setValue(
+      SettingScope.User,
+      'security.auth.selectedType',
+      method,
+    );
+  }
+
+  async newSession({
+    cwd,
+    mcpServers,
+  }: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {
+    const config = await this.newSessionConfig(cwd, mcpServers);
+    await this.ensureAuthenticated(config);
+    this.setupFileSystem(config);
+
+    const session = await this.createAndStoreSession(config);
+
+    return {
+      sessionId: session.getId(),
+    };
+  }
+
+  async newSessionConfig(
+    cwd: string,
+    mcpServers: acp.McpServer[],
+    sessionId?: string,
+  ): Promise<Config> {
+    const mergedMcpServers = { ...this.settings.merged.mcpServers };
+
+    for (const { command, args, env: rawEnv, name } of mcpServers) {
+      const env: Record<string, string> = {};
+      for (const { name: envName, value } of rawEnv) {
+        env[envName] = value;
+      }
+      mergedMcpServers[name] = new MCPServerConfig(command, args, env, cwd);
+    }
+
+    const settings = { ...this.settings.merged, mcpServers: mergedMcpServers };
+
+    const argvForSession = {
+      ...this.argv,
+      resume: sessionId,
+      continue: false,
+    };
+
+    const config = await loadCliConfig(
+      settings,
+      this.extensions,
+      new ExtensionEnablementManager(
+        ExtensionStorage.getUserExtensionsDir(),
+        this.argv.extensions,
+      ),
+      argvForSession,
+      cwd,
+    );
+
+    await config.initialize();
+    return config;
+  }
+
+  async cancel(params: acp.CancelNotification): Promise<void> {
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    await session.cancelPendingPrompt();
+  }
+
+  async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    return session.prompt(params);
+  }
+
+  async loadSession(
+    params: acp.LoadSessionRequest,
+  ): Promise<acp.LoadSessionResponse> {
+    const sessionService = new SessionService(params.cwd);
+    const exists = await sessionService.sessionExists(params.sessionId);
+    if (!exists) {
+      throw acp.RequestError.invalidParams(
+        `Session not found for id: ${params.sessionId}`,
+      );
+    }
+
+    const config = await this.newSessionConfig(
+      params.cwd,
+      params.mcpServers,
+      params.sessionId,
+    );
+    await this.ensureAuthenticated(config);
+    this.setupFileSystem(config);
+
+    const sessionData = config.getResumedSessionData();
+    if (!sessionData) {
+      throw acp.RequestError.internalError(
+        `Failed to load session data for id: ${params.sessionId}`,
+      );
+    }
+
+    await this.createAndStoreSession(config, sessionData.conversation);
+
+    return null;
+  }
+
+  async listSessions(
+    params: acp.ListSessionsRequest,
+  ): Promise<acp.ListSessionsResponse> {
+    const sessionService = new SessionService(params.cwd);
+    const result = await sessionService.listSessions({
+      cursor: params.cursor,
+      size: params.size,
+    });
+
+    return {
+      items: result.items.map((item) => ({
+        sessionId: item.sessionId,
+        cwd: item.cwd,
+        startTime: item.startTime,
+        mtime: item.mtime,
+        prompt: item.prompt,
+        gitBranch: item.gitBranch,
+        filePath: item.filePath,
+        messageCount: item.messageCount,
+      })),
+      nextCursor: result.nextCursor,
+      hasMore: result.hasMore,
+    };
+  }
+
+  async setMode(params: acp.SetModeRequest): Promise<acp.SetModeResponse> {
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    return session.setMode(params);
+  }
+
+  private async ensureAuthenticated(config: Config): Promise<void> {
+    const selectedType = this.settings.merged.security?.auth?.selectedType;
+    if (!selectedType) {
+      throw acp.RequestError.authRequired();
+    }
+
+    try {
+      await config.refreshAuth(selectedType);
+    } catch (e) {
+      console.error(`Authentication failed: ${e}`);
+      throw acp.RequestError.authRequired();
+    }
+  }
+
+  private setupFileSystem(config: Config): void {
+    if (!this.clientCapabilities?.fs) {
+      return;
+    }
+
+    const acpFileSystemService = new AcpFileSystemService(
+      this.client,
+      config.getSessionId(),
+      this.clientCapabilities.fs,
+      config.getFileSystemService(),
+    );
+    config.setFileSystemService(acpFileSystemService);
+  }
+
+  private async createAndStoreSession(
+    config: Config,
+    conversation?: ConversationRecord,
+  ): Promise<Session> {
+    const sessionId = config.getSessionId();
+    const geminiClient = config.getGeminiClient();
+
+    const history = conversation
+      ? buildApiHistoryFromConversation(conversation)
+      : undefined;
+    const chat = history
+      ? await geminiClient.startChat(history)
+      : await geminiClient.startChat();
+
+    const session = new Session(
+      sessionId,
+      chat,
+      config,
+      this.client,
+      this.settings,
+    );
+    this.sessions.set(sessionId, session);
+
+    setTimeout(async () => {
+      await session.sendAvailableCommandsUpdate();
+    }, 0);
+
+    if (conversation && conversation.messages) {
+      await session.replayHistory(conversation.messages);
+    }
+
+    return session;
+  }
+}

packages/cli/src/acp-integration/schema.ts

@@ -13,6 +13,8 @@ export const AGENT_METHODS = {
   session_load: 'session/load',
   session_new: 'session/new',
   session_prompt: 'session/prompt',
+  session_list: 'session/list',
+  session_set_mode: 'session/set_mode',
 };
 
 export const CLIENT_METHODS = {
@@ -47,6 +49,9 @@ export type ReadTextFileResponse = z.infer<typeof readTextFileResponseSchema>;
 export type RequestPermissionOutcome = z.infer<
   typeof requestPermissionOutcomeSchema
 >;
+export type SessionListItem = z.infer<typeof sessionListItemSchema>;
+export type ListSessionsRequest = z.infer<typeof listSessionsRequestSchema>;
+export type ListSessionsResponse = z.infer<typeof listSessionsResponseSchema>;
 
 export type CancelNotification = z.infer<typeof cancelNotificationSchema>;
 
@@ -84,6 +89,12 @@ export type AgentCapabilities = z.infer<typeof agentCapabilitiesSchema>;
 
 export type AuthMethod = z.infer<typeof authMethodSchema>;
 
+export type ModeInfo = z.infer<typeof modeInfoSchema>;
+
+export type ModesData = z.infer<typeof modesDataSchema>;
+
+export type AgentInfo = z.infer<typeof agentInfoSchema>;
+
 export type PromptCapabilities = z.infer<typeof promptCapabilitiesSchema>;
 
 export type ClientResponse = z.infer<typeof clientResponseSchema>;
@@ -128,6 +139,12 @@ export type AgentRequest = z.infer<typeof agentRequestSchema>;
 
 export type AgentNotification = z.infer<typeof agentNotificationSchema>;
 
+export type ApprovalModeValue = z.infer<typeof approvalModeValueSchema>;
+
+export type SetModeRequest = z.infer<typeof setModeRequestSchema>;
+
+export type SetModeResponse = z.infer<typeof setModeResponseSchema>;
+
 export type AvailableCommandInput = z.infer<typeof availableCommandInputSchema>;
 
 export type AvailableCommand = z.infer<typeof availableCommandSchema>;
@@ -179,6 +196,7 @@ export const toolKindSchema = z.union([
   z.literal('execute'),
   z.literal('think'),
   z.literal('fetch'),
+  z.literal('switch_mode'),
   z.literal('other'),
 ]);
 
@@ -209,6 +227,22 @@ export const cancelNotificationSchema = z.object({
   sessionId: z.string(),
 });
 
+export const approvalModeValueSchema = z.union([
+  z.literal('plan'),
+  z.literal('default'),
+  z.literal('auto-edit'),
+  z.literal('yolo'),
+]);
+
+export const setModeRequestSchema = z.object({
+  sessionId: z.string(),
+  modeId: approvalModeValueSchema,
+});
+
+export const setModeResponseSchema = z.object({
+  modeId: approvalModeValueSchema,
+});
+
 export const authenticateRequestSchema = z.object({
   methodId: z.string(),
 });
@@ -221,6 +255,29 @@ export const newSessionResponseSchema = z.object({
 
 export const loadSessionResponseSchema = z.null();
 
+export const sessionListItemSchema = z.object({
+  cwd: z.string(),
+  filePath: z.string(),
+  gitBranch: z.string().optional(),
+  messageCount: z.number(),
+  mtime: z.number(),
+  prompt: z.string(),
+  sessionId: z.string(),
+  startTime: z.string(),
+});
+
+export const listSessionsResponseSchema = z.object({
+  hasMore: z.boolean(),
+  items: z.array(sessionListItemSchema),
+  nextCursor: z.number().optional(),
+});
+
+export const listSessionsRequestSchema = z.object({
+  cursor: z.number().optional(),
+  cwd: z.string(),
+  size: z.number().optional(),
+});
+
 export const stopReasonSchema = z.union([
   z.literal('end_turn'),
   z.literal('max_tokens'),
@@ -321,9 +378,28 @@ export const loadSessionRequestSchema = z.object({
   sessionId: z.string(),
 });
 
+export const modeInfoSchema = z.object({
+  id: approvalModeValueSchema,
+  name: z.string(),
+  description: z.string(),
+});
+
+export const modesDataSchema = z.object({
+  currentModeId: approvalModeValueSchema,
+  availableModes: z.array(modeInfoSchema),
+});
+
+export const agentInfoSchema = z.object({
+  name: z.string(),
+  title: z.string(),
+  version: z.string(),
+});
+
 export const initializeResponseSchema = z.object({
   agentCapabilities: agentCapabilitiesSchema,
+  agentInfo: agentInfoSchema,
   authMethods: z.array(authMethodSchema),
+  modes: modesDataSchema,
   protocolVersion: z.number(),
 });
 
@@ -409,6 +485,13 @@ export const availableCommandsUpdateSchema = z.object({
   sessionUpdate: z.literal('available_commands_update'),
 });
 
+export const currentModeUpdateSchema = z.object({
+  sessionUpdate: z.literal('current_mode_update'),
+  modeId: approvalModeValueSchema,
+});
+
+export type CurrentModeUpdate = z.infer<typeof currentModeUpdateSchema>;
+
 export const sessionUpdateSchema = z.union([
   z.object({
     content: contentBlockSchema,
@@ -437,6 +520,7 @@ export const sessionUpdateSchema = z.union([
     kind: toolKindSchema.optional().nullable(),
     locations: z.array(toolCallLocationSchema).optional().nullable(),
     rawInput: z.unknown().optional(),
+    rawOutput: z.unknown().optional(),
     sessionUpdate: z.literal('tool_call_update'),
     status: toolCallStatusSchema.optional().nullable(),
     title: z.string().optional().nullable(),
@@ -446,6 +530,7 @@ export const sessionUpdateSchema = z.union([
     entries: z.array(planEntrySchema),
     sessionUpdate: z.literal('plan'),
   }),
+  currentModeUpdateSchema,
   availableCommandsUpdateSchema,
 ]);
 
@@ -455,6 +540,8 @@ export const agentResponseSchema = z.union([
   newSessionResponseSchema,
   loadSessionResponseSchema,
   promptResponseSchema,
+  listSessionsResponseSchema,
+  setModeResponseSchema,
 ]);
 
 export const requestPermissionRequestSchema = z.object({
@@ -485,6 +572,8 @@ export const agentRequestSchema = z.union([
   newSessionRequestSchema,
   loadSessionRequestSchema,
   promptRequestSchema,
+  listSessionsRequestSchema,
+  setModeRequestSchema,
 ]);
 
 export const agentNotificationSchema = sessionNotificationSchema;

packages/cli/src/acp-integration/service/filesystem.ts

@@ -5,7 +5,7 @@
  */
 
 import type { FileSystemService } from '@qwen-code/qwen-code-core';
-import type * as acp from './acp.js';
+import type * as acp from '../acp.js';
 
 /**
  * ACP client-based implementation of FileSystemService

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

@@ -0,0 +1,414 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HistoryReplayer } from './HistoryReplayer.js';
+import type { SessionContext } from './types.js';
+import type {
+  Config,
+  ChatRecord,
+  ToolRegistry,
+  ToolResultDisplay,
+  TodoResultDisplay,
+} from '@qwen-code/qwen-code-core';
+
+describe('HistoryReplayer', () => {
+  let mockContext: SessionContext;
+  let sendUpdateSpy: ReturnType<typeof vi.fn>;
+  let replayer: HistoryReplayer;
+
+  beforeEach(() => {
+    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
+    const mockToolRegistry = {
+      getTool: vi.fn().mockReturnValue(null),
+    } as unknown as ToolRegistry;
+
+    mockContext = {
+      sessionId: 'test-session-id',
+      config: {
+        getToolRegistry: () => mockToolRegistry,
+      } as unknown as Config,
+      sendUpdate: sendUpdateSpy,
+    };
+
+    replayer = new HistoryReplayer(mockContext);
+  });
+
+  const createUserRecord = (text: string): ChatRecord => ({
+    uuid: 'user-uuid',
+    parentUuid: null,
+    sessionId: 'test-session',
+    timestamp: new Date().toISOString(),
+    type: 'user',
+    cwd: '/test',
+    version: '1.0.0',
+    message: {
+      role: 'user',
+      parts: [{ text }],
+    },
+  });
+
+  const createAssistantRecord = (
+    text: string,
+    thought = false,
+  ): ChatRecord => ({
+    uuid: 'assistant-uuid',
+    parentUuid: 'user-uuid',
+    sessionId: 'test-session',
+    timestamp: new Date().toISOString(),
+    type: 'assistant',
+    cwd: '/test',
+    version: '1.0.0',
+    message: {
+      role: 'model',
+      parts: [{ text, thought }],
+    },
+  });
+
+  const createToolResultRecord = (
+    toolName: string,
+    resultDisplay?: ToolResultDisplay,
+    hasError = false,
+  ): ChatRecord => ({
+    uuid: 'tool-uuid',
+    parentUuid: 'assistant-uuid',
+    sessionId: 'test-session',
+    timestamp: new Date().toISOString(),
+    type: 'tool_result',
+    cwd: '/test',
+    version: '1.0.0',
+    message: {
+      role: 'user',
+      parts: [
+        {
+          functionResponse: {
+            name: toolName,
+            response: { result: 'ok' },
+          },
+        },
+      ],
+    },
+    toolCallResult: {
+      callId: 'call-123',
+      responseParts: [],
+      resultDisplay,
+      error: hasError ? new Error('Tool failed') : undefined,
+      errorType: undefined,
+    },
+  });
+
+  describe('replay', () => {
+    it('should replay empty records array', async () => {
+      await replayer.replay([]);
+
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should replay records in order', async () => {
+      const records = [
+        createUserRecord('Hello'),
+        createAssistantRecord('Hi there'),
+      ];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(2);
+      expect(sendUpdateSpy.mock.calls[0][0].sessionUpdate).toBe(
+        'user_message_chunk',
+      );
+      expect(sendUpdateSpy.mock.calls[1][0].sessionUpdate).toBe(
+        'agent_message_chunk',
+      );
+    });
+  });
+
+  describe('user message replay', () => {
+    it('should emit user_message_chunk for user records', async () => {
+      const records = [createUserRecord('Hello, world!')];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: 'Hello, world!' },
+      });
+    });
+
+    it('should skip user records without message', async () => {
+      const record: ChatRecord = {
+        ...createUserRecord('test'),
+        message: undefined,
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('assistant message replay', () => {
+    it('should emit agent_message_chunk for assistant records', async () => {
+      const records = [createAssistantRecord('I can help with that.')];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'I can help with that.' },
+      });
+    });
+
+    it('should emit agent_thought_chunk for thought parts', async () => {
+      const records = [createAssistantRecord('Thinking about this...', true)];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Thinking about this...' },
+      });
+    });
+
+    it('should handle assistant records with multiple parts', async () => {
+      const record: ChatRecord = {
+        ...createAssistantRecord('First'),
+        message: {
+          role: 'model',
+          parts: [
+            { text: 'First part' },
+            { text: 'Second part', thought: true },
+            { text: 'Third part' },
+          ],
+        },
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(3);
+      expect(sendUpdateSpy.mock.calls[0][0]).toEqual({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'First part' },
+      });
+      expect(sendUpdateSpy.mock.calls[1][0]).toEqual({
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Second part' },
+      });
+      expect(sendUpdateSpy.mock.calls[2][0]).toEqual({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Third part' },
+      });
+    });
+  });
+
+  describe('function call replay', () => {
+    it('should emit tool_call for function call parts', async () => {
+      const record: ChatRecord = {
+        ...createAssistantRecord(''),
+        message: {
+          role: 'model',
+          parts: [
+            {
+              functionCall: {
+                name: 'read_file',
+                args: { path: '/test.ts' },
+              },
+            },
+          ],
+        },
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call',
+          status: 'in_progress',
+          title: 'read_file',
+          rawInput: { path: '/test.ts' },
+        }),
+      );
+    });
+
+    it('should use function call id as callId when available', async () => {
+      const record: ChatRecord = {
+        ...createAssistantRecord(''),
+        message: {
+          role: 'model',
+          parts: [
+            {
+              functionCall: {
+                id: 'custom-call-id',
+                name: 'read_file',
+                args: {},
+              },
+            },
+          ],
+        },
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolCallId: 'custom-call-id',
+        }),
+      );
+    });
+  });
+
+  describe('tool result replay', () => {
+    it('should emit tool_call_update for tool result records', async () => {
+      const records = [
+        createToolResultRecord('read_file', 'File contents here'),
+      ];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call_update',
+        toolCallId: 'call-123',
+        status: 'completed',
+        content: [
+          {
+            type: 'content',
+            // Content comes from functionResponse.response (stringified)
+            content: { type: 'text', text: '{"result":"ok"}' },
+          },
+        ],
+        // resultDisplay is included as rawOutput
+        rawOutput: 'File contents here',
+      });
+    });
+
+    it('should emit failed status for tool results with errors', async () => {
+      const records = [createToolResultRecord('failing_tool', undefined, true)];
+
+      await replayer.replay(records);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call_update',
+          status: 'failed',
+        }),
+      );
+    });
+
+    it('should emit plan update for TodoWriteTool results', async () => {
+      const todoDisplay: TodoResultDisplay = {
+        type: 'todo_list',
+        todos: [
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'completed' },
+        ],
+      };
+      const record = createToolResultRecord('todo_write', todoDisplay);
+      // Override the function response name
+      record.message = {
+        role: 'user',
+        parts: [
+          {
+            functionResponse: {
+              name: 'todo_write',
+              response: { result: 'ok' },
+            },
+          },
+        ],
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'plan',
+        entries: [
+          { content: 'Task 1', priority: 'medium', status: 'pending' },
+          { content: 'Task 2', priority: 'medium', status: 'completed' },
+        ],
+      });
+    });
+
+    it('should use record uuid as callId when toolCallResult.callId is missing', async () => {
+      const record: ChatRecord = {
+        ...createToolResultRecord('test_tool'),
+        uuid: 'fallback-uuid',
+        toolCallResult: {
+          callId: undefined as unknown as string,
+          responseParts: [],
+          resultDisplay: 'Result',
+          error: undefined,
+          errorType: undefined,
+        },
+      };
+
+      await replayer.replay([record]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolCallId: 'fallback-uuid',
+        }),
+      );
+    });
+  });
+
+  describe('system records', () => {
+    it('should skip system records', async () => {
+      const systemRecord: ChatRecord = {
+        uuid: 'system-uuid',
+        parentUuid: null,
+        sessionId: 'test-session',
+        timestamp: new Date().toISOString(),
+        type: 'system',
+        subtype: 'chat_compression',
+        cwd: '/test',
+        version: '1.0.0',
+      };
+
+      await replayer.replay([systemRecord]);
+
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('mixed record types', () => {
+    it('should handle a complete conversation replay', async () => {
+      const records: ChatRecord[] = [
+        createUserRecord('Read the file test.ts'),
+        {
+          ...createAssistantRecord(''),
+          message: {
+            role: 'model',
+            parts: [
+              { text: "I'll read that file for you.", thought: true },
+              {
+                functionCall: {
+                  id: 'call-read',
+                  name: 'read_file',
+                  args: { path: 'test.ts' },
+                },
+              },
+            ],
+          },
+        },
+        createToolResultRecord('read_file', 'export const x = 1;'),
+        createAssistantRecord('The file contains a simple export.'),
+      ];
+
+      await replayer.replay(records);
+
+      // Verify order and types of updates
+      const updateTypes = sendUpdateSpy.mock.calls.map(
+        (call: unknown[]) =>
+          (call[0] as { sessionUpdate: string }).sessionUpdate,
+      );
+      expect(updateTypes).toEqual([
+        'user_message_chunk',
+        'agent_thought_chunk',
+        'tool_call',
+        'tool_call_update',
+        'agent_message_chunk',
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,137 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+import type { Content } from '@google/genai';
+import type { SessionContext } from './types.js';
+import { MessageEmitter } from './emitters/MessageEmitter.js';
+import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
+
+/**
+ * Handles replaying session history on session load.
+ *
+ * Uses the unified emitters to ensure consistency with normal flow.
+ * This ensures that replayed history looks identical to how it would
+ * have appeared during the original session.
+ */
+export class HistoryReplayer {
+  private readonly messageEmitter: MessageEmitter;
+  private readonly toolCallEmitter: ToolCallEmitter;
+
+  constructor(ctx: SessionContext) {
+    this.messageEmitter = new MessageEmitter(ctx);
+    this.toolCallEmitter = new ToolCallEmitter(ctx);
+  }
+
+  /**
+   * Replays all chat records from a loaded session.
+   *
+   * @param records - Array of chat records to replay
+   */
+  async replay(records: ChatRecord[]): Promise<void> {
+    for (const record of records) {
+      await this.replayRecord(record);
+    }
+  }
+
+  /**
+   * Replays a single chat record.
+   */
+  private async replayRecord(record: ChatRecord): Promise<void> {
+    switch (record.type) {
+      case 'user':
+        if (record.message) {
+          await this.replayContent(record.message, 'user');
+        }
+        break;
+
+      case 'assistant':
+        if (record.message) {
+          await this.replayContent(record.message, 'assistant');
+        }
+        break;
+
+      case 'tool_result':
+        await this.replayToolResult(record);
+        break;
+
+      default:
+        // Skip system records (compression, telemetry, slash commands)
+        break;
+    }
+  }
+
+  /**
+   * Replays content from a message (user or assistant).
+   * Handles text parts, thought parts, and function calls.
+   */
+  private async replayContent(
+    content: Content,
+    role: 'user' | 'assistant',
+  ): Promise<void> {
+    for (const part of content.parts ?? []) {
+      // Text content
+      if ('text' in part && part.text) {
+        const isThought = (part as { thought?: boolean }).thought ?? false;
+        await this.messageEmitter.emitMessage(part.text, role, isThought);
+      }
+
+      // Function call (tool start)
+      if ('functionCall' in part && part.functionCall) {
+        const functionName = part.functionCall.name ?? '';
+        const callId = part.functionCall.id ?? `${functionName}-${Date.now()}`;
+
+        await this.toolCallEmitter.emitStart({
+          toolName: functionName,
+          callId,
+          args: part.functionCall.args as Record<string, unknown>,
+        });
+      }
+    }
+  }
+
+  /**
+   * Replays a tool result record.
+   */
+  private async replayToolResult(record: ChatRecord): Promise<void> {
+    // message is required - skip if not present
+    if (!record.message?.parts) {
+      return;
+    }
+
+    const result = record.toolCallResult;
+    const callId = result?.callId ?? record.uuid;
+
+    // Extract tool name from the function response in message if available
+    const toolName = this.extractToolNameFromRecord(record);
+
+    await this.toolCallEmitter.emitResult({
+      toolName,
+      callId,
+      success: !result?.error,
+      message: record.message.parts,
+      resultDisplay: result?.resultDisplay,
+      // For TodoWriteTool fallback, try to extract args from the record
+      // Note: args aren't stored in tool_result records by default
+      args: undefined,
+    });
+  }
+
+  /**
+   * Extracts tool name from a chat record's function response.
+   */
+  private extractToolNameFromRecord(record: ChatRecord): string {
+    // Try to get from functionResponse in message
+    if (record.message?.parts) {
+      for (const part of record.message.parts) {
+        if ('functionResponse' in part && part.functionResponse?.name) {
+          return part.functionResponse.name;
+        }
+      }
+    }
+    return '';
+  }
+}

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

@@ -0,0 +1,981 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Content, FunctionCall, Part } from '@google/genai';
+import type {
+  Config,
+  GeminiChat,
+  ToolCallConfirmationDetails,
+  ToolResult,
+  ChatRecord,
+  SubAgentEventEmitter,
+} from '@qwen-code/qwen-code-core';
+import {
+  ApprovalMode,
+  convertToFunctionResponse,
+  DiscoveredMCPTool,
+  StreamEventType,
+  ToolConfirmationOutcome,
+  logToolCall,
+  logUserPrompt,
+  getErrorStatus,
+  isWithinRoot,
+  isNodeError,
+  TaskTool,
+  UserPromptEvent,
+  TodoWriteTool,
+  ExitPlanModeTool,
+} from '@qwen-code/qwen-code-core';
+
+import * as acp from '../acp.js';
+import type { LoadedSettings } from '../../config/settings.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { getErrorMessage } from '../../utils/errors.js';
+import {
+  handleSlashCommand,
+  getAvailableCommands,
+} from '../../nonInteractiveCliCommands.js';
+import type {
+  AvailableCommand,
+  AvailableCommandsUpdate,
+  SetModeRequest,
+  SetModeResponse,
+  ApprovalModeValue,
+  CurrentModeUpdate,
+} from '../schema.js';
+import { isSlashCommand } from '../../ui/utils/commandUtils.js';
+
+// Import modular session components
+import type { SessionContext, ToolCallStartParams } from './types.js';
+import { HistoryReplayer } from './HistoryReplayer.js';
+import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
+import { PlanEmitter } from './emitters/PlanEmitter.js';
+import { SubAgentTracker } from './SubAgentTracker.js';
+
+/**
+ * Built-in commands that are allowed in ACP integration mode.
+ * Only safe, read-only commands that don't require interactive UI.
+ */
+export const ALLOWED_BUILTIN_COMMANDS_FOR_ACP = ['init'];
+
+/**
+ * Session represents an active conversation session with the AI model.
+ * It uses modular components for consistent event emission:
+ * - HistoryReplayer for replaying past conversations
+ * - ToolCallEmitter for tool-related session updates
+ * - PlanEmitter for todo/plan updates
+ * - SubAgentTracker for tracking sub-agent tool calls
+ */
+export class Session implements SessionContext {
+  private pendingPrompt: AbortController | null = null;
+  private turn: number = 0;
+
+  // Modular components
+  private readonly historyReplayer: HistoryReplayer;
+  private readonly toolCallEmitter: ToolCallEmitter;
+  private readonly planEmitter: PlanEmitter;
+
+  // Implement SessionContext interface
+  readonly sessionId: string;
+
+  constructor(
+    id: string,
+    private readonly chat: GeminiChat,
+    readonly config: Config,
+    private readonly client: acp.Client,
+    private readonly settings: LoadedSettings,
+  ) {
+    this.sessionId = id;
+
+    // Initialize modular components with this session as context
+    this.toolCallEmitter = new ToolCallEmitter(this);
+    this.planEmitter = new PlanEmitter(this);
+    this.historyReplayer = new HistoryReplayer(this);
+  }
+
+  getId(): string {
+    return this.sessionId;
+  }
+
+  getConfig(): Config {
+    return this.config;
+  }
+
+  /**
+   * Replays conversation history to the client using modular components.
+   * Delegates to HistoryReplayer for consistent event emission.
+   */
+  async replayHistory(records: ChatRecord[]): Promise<void> {
+    await this.historyReplayer.replay(records);
+  }
+
+  async cancelPendingPrompt(): Promise<void> {
+    if (!this.pendingPrompt) {
+      throw new Error('Not currently generating');
+    }
+
+    this.pendingPrompt.abort();
+    this.pendingPrompt = null;
+  }
+
+  async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
+    this.pendingPrompt?.abort();
+    const pendingSend = new AbortController();
+    this.pendingPrompt = pendingSend;
+
+    // Increment turn counter for each user prompt
+    this.turn += 1;
+
+    const chat = this.chat;
+    const promptId = this.config.getSessionId() + '########' + this.turn;
+
+    // Extract text from all text blocks to construct the full prompt text for logging
+    const promptText = params.prompt
+      .filter((block) => block.type === 'text')
+      .map((block) => (block.type === 'text' ? block.text : ''))
+      .join(' ');
+
+    // Log user prompt
+    logUserPrompt(
+      this.config,
+      new UserPromptEvent(
+        promptText.length,
+        promptId,
+        this.config.getContentGeneratorConfig()?.authType,
+        promptText,
+      ),
+    );
+
+    // record user message for session management
+    this.config.getChatRecordingService()?.recordUserMessage(promptText);
+
+    // Check if the input contains a slash command
+    // Extract text from the first text block if present
+    const firstTextBlock = params.prompt.find((block) => block.type === 'text');
+    const inputText = firstTextBlock?.text || '';
+
+    let parts: Part[];
+
+    if (isSlashCommand(inputText)) {
+      // Handle slash command - allow specific built-in commands for ACP integration
+      const slashCommandResult = await handleSlashCommand(
+        inputText,
+        pendingSend,
+        this.config,
+        this.settings,
+        ALLOWED_BUILTIN_COMMANDS_FOR_ACP,
+      );
+
+      if (slashCommandResult) {
+        // Use the result from the slash command
+        parts = slashCommandResult as Part[];
+      } else {
+        // Slash command didn't return a prompt, continue with normal processing
+        parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
+      }
+    } else {
+      // Normal processing for non-slash commands
+      parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
+    }
+
+    let nextMessage: Content | null = { role: 'user', parts };
+
+    while (nextMessage !== null) {
+      if (pendingSend.signal.aborted) {
+        chat.addHistory(nextMessage);
+        return { stopReason: 'cancelled' };
+      }
+
+      const functionCalls: FunctionCall[] = [];
+
+      try {
+        const responseStream = await chat.sendMessageStream(
+          this.config.getModel(),
+          {
+            message: nextMessage?.parts ?? [],
+            config: {
+              abortSignal: pendingSend.signal,
+            },
+          },
+          promptId,
+        );
+        nextMessage = null;
+
+        for await (const resp of responseStream) {
+          if (pendingSend.signal.aborted) {
+            return { stopReason: 'cancelled' };
+          }
+
+          if (
+            resp.type === StreamEventType.CHUNK &&
+            resp.value.candidates &&
+            resp.value.candidates.length > 0
+          ) {
+            const candidate = resp.value.candidates[0];
+            for (const part of candidate.content?.parts ?? []) {
+              if (!part.text) {
+                continue;
+              }
+
+              const content: acp.ContentBlock = {
+                type: 'text',
+                text: part.text,
+              };
+
+              this.sendUpdate({
+                sessionUpdate: part.thought
+                  ? 'agent_thought_chunk'
+                  : 'agent_message_chunk',
+                content,
+              });
+            }
+          }
+
+          if (resp.type === StreamEventType.CHUNK && resp.value.functionCalls) {
+            functionCalls.push(...resp.value.functionCalls);
+          }
+        }
+      } catch (error) {
+        if (getErrorStatus(error) === 429) {
+          throw new acp.RequestError(
+            429,
+            'Rate limit exceeded. Try again later.',
+          );
+        }
+
+        throw error;
+      }
+
+      if (functionCalls.length > 0) {
+        const toolResponseParts: Part[] = [];
+
+        for (const fc of functionCalls) {
+          const response = await this.runTool(pendingSend.signal, promptId, fc);
+          toolResponseParts.push(...response);
+        }
+
+        nextMessage = { role: 'user', parts: toolResponseParts };
+      }
+    }
+
+    return { stopReason: 'end_turn' };
+  }
+
+  async sendUpdate(update: acp.SessionUpdate): Promise<void> {
+    const params: acp.SessionNotification = {
+      sessionId: this.sessionId,
+      update,
+    };
+
+    await this.client.sessionUpdate(params);
+  }
+
+  async sendAvailableCommandsUpdate(): Promise<void> {
+    const abortController = new AbortController();
+    try {
+      const slashCommands = await getAvailableCommands(
+        this.config,
+        this.settings,
+        abortController.signal,
+        ALLOWED_BUILTIN_COMMANDS_FOR_ACP,
+      );
+
+      // Convert SlashCommand[] to AvailableCommand[] format for ACP protocol
+      const availableCommands: AvailableCommand[] = slashCommands.map(
+        (cmd) => ({
+          name: cmd.name,
+          description: cmd.description,
+          input: null,
+        }),
+      );
+
+      const update: AvailableCommandsUpdate = {
+        sessionUpdate: 'available_commands_update',
+        availableCommands,
+      };
+
+      await this.sendUpdate(update);
+    } catch (error) {
+      // Log error but don't fail session creation
+      console.error('Error sending available commands update:', error);
+    }
+  }
+
+  /**
+   * Requests permission from the client for a tool call.
+   * Used by SubAgentTracker for sub-agent approval requests.
+   */
+  async requestPermission(
+    params: acp.RequestPermissionRequest,
+  ): Promise<acp.RequestPermissionResponse> {
+    return this.client.requestPermission(params);
+  }
+
+  /**
+   * Sets the approval mode for the current session.
+   * Maps ACP approval mode values to core ApprovalMode enum.
+   */
+  async setMode(params: SetModeRequest): Promise<SetModeResponse> {
+    const modeMap: Record<ApprovalModeValue, ApprovalMode> = {
+      plan: ApprovalMode.PLAN,
+      default: ApprovalMode.DEFAULT,
+      'auto-edit': ApprovalMode.AUTO_EDIT,
+      yolo: ApprovalMode.YOLO,
+    };
+
+    const approvalMode = modeMap[params.modeId];
+    this.config.setApprovalMode(approvalMode);
+
+    return { modeId: params.modeId };
+  }
+
+  /**
+   * Sends a current_mode_update notification to the client.
+   * Called after the agent switches modes (e.g., from exit_plan_mode tool).
+   */
+  private async sendCurrentModeUpdateNotification(
+    outcome: ToolConfirmationOutcome,
+  ): Promise<void> {
+    // Determine the new mode based on the approval outcome
+    // This mirrors the logic in ExitPlanModeTool.onConfirm
+    let newModeId: ApprovalModeValue;
+    switch (outcome) {
+      case ToolConfirmationOutcome.ProceedAlways:
+        newModeId = 'auto-edit';
+        break;
+      case ToolConfirmationOutcome.ProceedOnce:
+      default:
+        newModeId = 'default';
+        break;
+    }
+
+    const update: CurrentModeUpdate = {
+      sessionUpdate: 'current_mode_update',
+      modeId: newModeId,
+    };
+
+    await this.sendUpdate(update);
+  }
+
+  private async runTool(
+    abortSignal: AbortSignal,
+    promptId: string,
+    fc: FunctionCall,
+  ): Promise<Part[]> {
+    const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+    const args = (fc.args ?? {}) as Record<string, unknown>;
+
+    const startTime = Date.now();
+
+    const errorResponse = (error: Error) => {
+      const durationMs = Date.now() - startTime;
+      logToolCall(this.config, {
+        'event.name': 'tool_call',
+        'event.timestamp': new Date().toISOString(),
+        prompt_id: promptId,
+        function_name: fc.name ?? '',
+        function_args: args,
+        duration_ms: durationMs,
+        status: 'error',
+        success: false,
+        error: error.message,
+        tool_type:
+          typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+            ? 'mcp'
+            : 'native',
+      });
+
+      return [
+        {
+          functionResponse: {
+            id: callId,
+            name: fc.name ?? '',
+            response: { error: error.message },
+          },
+        },
+      ];
+    };
+
+    if (!fc.name) {
+      return errorResponse(new Error('Missing function name'));
+    }
+
+    const toolRegistry = this.config.getToolRegistry();
+    const tool = toolRegistry.getTool(fc.name as string);
+
+    if (!tool) {
+      return errorResponse(
+        new Error(`Tool "${fc.name}" not found in registry.`),
+      );
+    }
+
+    // Detect TodoWriteTool early - route to plan updates instead of tool_call events
+    const isTodoWriteTool = tool.name === TodoWriteTool.Name;
+    const isTaskTool = tool.name === TaskTool.Name;
+    const isExitPlanModeTool = tool.name === ExitPlanModeTool.Name;
+
+    // Track cleanup functions for sub-agent event listeners
+    let subAgentCleanupFunctions: Array<() => void> = [];
+
+    try {
+      const invocation = tool.build(args);
+
+      if (isTaskTool && 'eventEmitter' in invocation) {
+        // Access eventEmitter from TaskTool invocation
+        const taskEventEmitter = (
+          invocation as {
+            eventEmitter: SubAgentEventEmitter;
+          }
+        ).eventEmitter;
+
+        // Create a SubAgentTracker for this tool execution
+        const subAgentTracker = new SubAgentTracker(this, this.client);
+
+        // Set up sub-agent tool tracking
+        subAgentCleanupFunctions = subAgentTracker.setup(
+          taskEventEmitter,
+          abortSignal,
+        );
+      }
+
+      const confirmationDetails =
+        await invocation.shouldConfirmExecute(abortSignal);
+
+      if (confirmationDetails) {
+        const content: acp.ToolCallContent[] = [];
+
+        if (confirmationDetails.type === 'edit') {
+          content.push({
+            type: 'diff',
+            path: confirmationDetails.fileName,
+            oldText: confirmationDetails.originalContent,
+            newText: confirmationDetails.newContent,
+          });
+        }
+
+        // Add plan content for exit_plan_mode
+        if (confirmationDetails.type === 'plan') {
+          content.push({
+            type: 'content',
+            content: {
+              type: 'text',
+              text: confirmationDetails.plan,
+            },
+          });
+        }
+
+        // Map tool kind, using switch_mode for exit_plan_mode per ACP spec
+        const mappedKind = this.toolCallEmitter.mapToolKind(tool.kind, fc.name);
+
+        const params: acp.RequestPermissionRequest = {
+          sessionId: this.sessionId,
+          options: toPermissionOptions(confirmationDetails),
+          toolCall: {
+            toolCallId: callId,
+            status: 'pending',
+            title: invocation.getDescription(),
+            content,
+            locations: invocation.toolLocations(),
+            kind: mappedKind,
+          },
+        };
+
+        const output = await this.client.requestPermission(params);
+        const outcome =
+          output.outcome.outcome === 'cancelled'
+            ? ToolConfirmationOutcome.Cancel
+            : z
+                .nativeEnum(ToolConfirmationOutcome)
+                .parse(output.outcome.optionId);
+
+        await confirmationDetails.onConfirm(outcome);
+
+        // After exit_plan_mode confirmation, send current_mode_update notification
+        if (isExitPlanModeTool && outcome !== ToolConfirmationOutcome.Cancel) {
+          await this.sendCurrentModeUpdateNotification(outcome);
+        }
+
+        switch (outcome) {
+          case ToolConfirmationOutcome.Cancel:
+            return errorResponse(
+              new Error(`Tool "${fc.name}" was canceled by the user.`),
+            );
+          case ToolConfirmationOutcome.ProceedOnce:
+          case ToolConfirmationOutcome.ProceedAlways:
+          case ToolConfirmationOutcome.ProceedAlwaysServer:
+          case ToolConfirmationOutcome.ProceedAlwaysTool:
+          case ToolConfirmationOutcome.ModifyWithEditor:
+            break;
+          default: {
+            const resultOutcome: never = outcome;
+            throw new Error(`Unexpected: ${resultOutcome}`);
+          }
+        }
+      } else if (!isTodoWriteTool) {
+        // Skip tool_call event for TodoWriteTool - use ToolCallEmitter
+        const startParams: ToolCallStartParams = {
+          callId,
+          toolName: fc.name,
+          args,
+        };
+        await this.toolCallEmitter.emitStart(startParams);
+      }
+
+      const toolResult: ToolResult = await invocation.execute(abortSignal);
+
+      // Clean up event listeners
+      subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+
+      // Create response parts first (needed for emitResult and recordToolResult)
+      const responseParts = convertToFunctionResponse(
+        fc.name,
+        callId,
+        toolResult.llmContent,
+      );
+
+      // Handle TodoWriteTool: extract todos and send plan update
+      if (isTodoWriteTool) {
+        const todos = this.planEmitter.extractTodos(
+          toolResult.returnDisplay,
+          args,
+        );
+
+        // Match original logic: emit plan if todos.length > 0 OR if args had todos
+        if ((todos && todos.length > 0) || Array.isArray(args['todos'])) {
+          await this.planEmitter.emitPlan(todos ?? []);
+        }
+
+        // Skip tool_call_update event for TodoWriteTool
+        // Still log and return function response for LLM
+      } else {
+        // Normal tool handling: emit result using ToolCallEmitter
+        // Convert toolResult.error to Error type if present
+        const error = toolResult.error
+          ? new Error(toolResult.error.message)
+          : undefined;
+
+        await this.toolCallEmitter.emitResult({
+          callId,
+          toolName: fc.name,
+          args,
+          message: responseParts,
+          resultDisplay: toolResult.returnDisplay,
+          error,
+          success: !toolResult.error,
+        });
+      }
+
+      const durationMs = Date.now() - startTime;
+      logToolCall(this.config, {
+        'event.name': 'tool_call',
+        'event.timestamp': new Date().toISOString(),
+        function_name: fc.name,
+        function_args: args,
+        duration_ms: durationMs,
+        status: 'success',
+        success: true,
+        prompt_id: promptId,
+        tool_type:
+          typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+            ? 'mcp'
+            : 'native',
+      });
+
+      // Record tool result for session management
+      this.config.getChatRecordingService()?.recordToolResult(responseParts, {
+        callId,
+        status: 'success',
+        resultDisplay: toolResult.returnDisplay,
+        error: undefined,
+        errorType: undefined,
+      });
+
+      return responseParts;
+    } catch (e) {
+      // Ensure cleanup on error
+      subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+
+      const error = e instanceof Error ? e : new Error(String(e));
+
+      // Use ToolCallEmitter for error handling
+      await this.toolCallEmitter.emitError(callId, error);
+
+      // Record tool error for session management
+      const errorParts = [
+        {
+          functionResponse: {
+            id: callId,
+            name: fc.name ?? '',
+            response: { error: error.message },
+          },
+        },
+      ];
+      this.config.getChatRecordingService()?.recordToolResult(errorParts, {
+        callId,
+        status: 'error',
+        resultDisplay: undefined,
+        error,
+        errorType: undefined,
+      });
+
+      return errorResponse(error);
+    }
+  }
+
+  async #resolvePrompt(
+    message: acp.ContentBlock[],
+    abortSignal: AbortSignal,
+  ): Promise<Part[]> {
+    const FILE_URI_SCHEME = 'file://';
+
+    const embeddedContext: acp.EmbeddedResourceResource[] = [];
+
+    const parts = message.map((part) => {
+      switch (part.type) {
+        case 'text':
+          return { text: part.text };
+        case 'image':
+        case 'audio':
+          return {
+            inlineData: {
+              mimeType: part.mimeType,
+              data: part.data,
+            },
+          };
+        case 'resource_link': {
+          if (part.uri.startsWith(FILE_URI_SCHEME)) {
+            return {
+              fileData: {
+                mimeData: part.mimeType,
+                name: part.name,
+                fileUri: part.uri.slice(FILE_URI_SCHEME.length),
+              },
+            };
+          } else {
+            return { text: `@${part.uri}` };
+          }
+        }
+        case 'resource': {
+          embeddedContext.push(part.resource);
+          return { text: `@${part.resource.uri}` };
+        }
+        default: {
+          const unreachable: never = part;
+          throw new Error(`Unexpected chunk type: '${unreachable}'`);
+        }
+      }
+    });
+
+    const atPathCommandParts = parts.filter((part) => 'fileData' in part);
+
+    if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
+      return parts;
+    }
+
+    const atPathToResolvedSpecMap = new Map<string, string>();
+
+    // Get centralized file discovery service
+    const fileDiscovery = this.config.getFileService();
+    const respectGitIgnore = this.config.getFileFilteringRespectGitIgnore();
+
+    const pathSpecsToRead: string[] = [];
+    const contentLabelsForDisplay: string[] = [];
+    const ignoredPaths: string[] = [];
+
+    const toolRegistry = this.config.getToolRegistry();
+    const readManyFilesTool = toolRegistry.getTool('read_many_files');
+    const globTool = toolRegistry.getTool('glob');
+
+    if (!readManyFilesTool) {
+      throw new Error('Error: read_many_files tool not found.');
+    }
+
+    for (const atPathPart of atPathCommandParts) {
+      const pathName = atPathPart.fileData!.fileUri;
+      // Check if path should be ignored by git
+      if (fileDiscovery.shouldGitIgnoreFile(pathName)) {
+        ignoredPaths.push(pathName);
+        const reason = respectGitIgnore
+          ? 'git-ignored and will be skipped'
+          : 'ignored by custom patterns';
+        console.warn(`Path ${pathName} is ${reason}.`);
+        continue;
+      }
+      let currentPathSpec = pathName;
+      let resolvedSuccessfully = false;
+      try {
+        const absolutePath = path.resolve(this.config.getTargetDir(), pathName);
+        if (isWithinRoot(absolutePath, this.config.getTargetDir())) {
+          const stats = await fs.stat(absolutePath);
+          if (stats.isDirectory()) {
+            currentPathSpec = pathName.endsWith('/')
+              ? `${pathName}**`
+              : `${pathName}/**`;
+            this.debug(
+              `Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`,
+            );
+          } else {
+            this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+          }
+          resolvedSuccessfully = true;
+        } else {
+          this.debug(
+            `Path ${pathName} is outside the project directory. Skipping.`,
+          );
+        }
+      } catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+          if (this.config.getEnableRecursiveFileSearch() && globTool) {
+            this.debug(
+              `Path ${pathName} not found directly, attempting glob search.`,
+            );
+            try {
+              const globResult = await globTool.buildAndExecute(
+                {
+                  pattern: `**/*${pathName}*`,
+                  path: this.config.getTargetDir(),
+                },
+                abortSignal,
+              );
+              if (
+                globResult.llmContent &&
+                typeof globResult.llmContent === 'string' &&
+                !globResult.llmContent.startsWith('No files found') &&
+                !globResult.llmContent.startsWith('Error:')
+              ) {
+                const lines = globResult.llmContent.split('\n');
+                if (lines.length > 1 && lines[1]) {
+                  const firstMatchAbsolute = lines[1].trim();
+                  currentPathSpec = path.relative(
+                    this.config.getTargetDir(),
+                    firstMatchAbsolute,
+                  );
+                  this.debug(
+                    `Glob search for ${pathName} found ${firstMatchAbsolute}, using relative path: ${currentPathSpec}`,
+                  );
+                  resolvedSuccessfully = true;
+                } else {
+                  this.debug(
+                    `Glob search for '**/*${pathName}*' did not return a usable path. Path ${pathName} will be skipped.`,
+                  );
+                }
+              } else {
+                this.debug(
+                  `Glob search for '**/*${pathName}*' found no files or an error. Path ${pathName} will be skipped.`,
+                );
+              }
+            } catch (globError) {
+              console.error(
+                `Error during glob search for ${pathName}: ${getErrorMessage(globError)}`,
+              );
+            }
+          } else {
+            this.debug(
+              `Glob tool not found. Path ${pathName} will be skipped.`,
+            );
+          }
+        } else {
+          console.error(
+            `Error stating path ${pathName}. Path ${pathName} will be skipped.`,
+          );
+        }
+      }
+      if (resolvedSuccessfully) {
+        pathSpecsToRead.push(currentPathSpec);
+        atPathToResolvedSpecMap.set(pathName, currentPathSpec);
+        contentLabelsForDisplay.push(pathName);
+      }
+    }
+
+    // Construct the initial part of the query for the LLM
+    let initialQueryText = '';
+    for (let i = 0; i < parts.length; i++) {
+      const chunk = parts[i];
+      if ('text' in chunk) {
+        initialQueryText += chunk.text;
+      } else {
+        // type === 'atPath'
+        const resolvedSpec =
+          chunk.fileData && atPathToResolvedSpecMap.get(chunk.fileData.fileUri);
+        if (
+          i > 0 &&
+          initialQueryText.length > 0 &&
+          !initialQueryText.endsWith(' ') &&
+          resolvedSpec
+        ) {
+          // Add space if previous part was text and didn't end with space, or if previous was @path
+          const prevPart = parts[i - 1];
+          if (
+            'text' in prevPart ||
+            ('fileData' in prevPart &&
+              atPathToResolvedSpecMap.has(prevPart.fileData!.fileUri))
+          ) {
+            initialQueryText += ' ';
+          }
+        }
+        // Append the resolved path spec for display purposes
+        if (resolvedSpec) {
+          initialQueryText += `@${resolvedSpec}`;
+        }
+      }
+    }
+
+    // Handle ignored paths message
+    let ignoredPathsMessage = '';
+    if (ignoredPaths.length > 0) {
+      const pathList = ignoredPaths.map((p) => `- ${p}`).join('\n');
+      ignoredPathsMessage = `Note: The following paths were skipped because they are ignored:\n${pathList}\n\n`;
+    }
+
+    const processedQueryParts: Part[] = [];
+
+    // Read files using read_many_files tool
+    if (pathSpecsToRead.length > 0) {
+      const readResult = await readManyFilesTool.buildAndExecute(
+        {
+          paths_with_line_ranges: pathSpecsToRead,
+        },
+        abortSignal,
+      );
+
+      const contentForLlm =
+        typeof readResult.llmContent === 'string'
+          ? readResult.llmContent
+          : JSON.stringify(readResult.llmContent);
+
+      // Combine content label, ignored paths message, file content, and user query
+      const combinedText = `${ignoredPathsMessage}${contentForLlm}`.trim();
+      processedQueryParts.push({ text: combinedText });
+      processedQueryParts.push({ text: initialQueryText });
+    } else if (embeddedContext.length > 0) {
+      // No @path files to read, but we have embedded context
+      processedQueryParts.push({
+        text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
+      });
+    } else {
+      // No @path files found or resolved
+      processedQueryParts.push({
+        text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
+      });
+    }
+
+    // Process embedded context from resource blocks
+    for (const contextPart of embeddedContext) {
+      // Type guard for text resources
+      if ('text' in contextPart && contextPart.text) {
+        processedQueryParts.push({
+          text: `File: ${contextPart.uri}\n${contextPart.text}`,
+        });
+      }
+      // Type guard for blob resources
+      if ('blob' in contextPart && contextPart.blob) {
+        processedQueryParts.push({
+          inlineData: {
+            mimeType: contextPart.mimeType ?? 'application/octet-stream',
+            data: contextPart.blob,
+          },
+        });
+      }
+    }
+
+    return processedQueryParts;
+  }
+
+  debug(msg: string): void {
+    if (this.config.getDebugMode()) {
+      console.warn(msg);
+    }
+  }
+}
+
+// ============================================================================
+// Helper functions
+// ============================================================================
+
+const basicPermissionOptions = [
+  {
+    optionId: ToolConfirmationOutcome.ProceedOnce,
+    name: 'Allow',
+    kind: 'allow_once',
+  },
+  {
+    optionId: ToolConfirmationOutcome.Cancel,
+    name: 'Reject',
+    kind: 'reject_once',
+  },
+] as const;
+
+function toPermissionOptions(
+  confirmation: ToolCallConfirmationDetails,
+): acp.PermissionOption[] {
+  switch (confirmation.type) {
+    case 'edit':
+      return [
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlways,
+          name: 'Allow All Edits',
+          kind: 'allow_always',
+        },
+        ...basicPermissionOptions,
+      ];
+    case 'exec':
+      return [
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlways,
+          name: `Always Allow ${confirmation.rootCommand}`,
+          kind: 'allow_always',
+        },
+        ...basicPermissionOptions,
+      ];
+    case 'mcp':
+      return [
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
+          name: `Always Allow ${confirmation.serverName}`,
+          kind: 'allow_always',
+        },
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
+          name: `Always Allow ${confirmation.toolName}`,
+          kind: 'allow_always',
+        },
+        ...basicPermissionOptions,
+      ];
+    case 'info':
+      return [
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlways,
+          name: `Always Allow`,
+          kind: 'allow_always',
+        },
+        ...basicPermissionOptions,
+      ];
+    case 'plan':
+      return [
+        {
+          optionId: ToolConfirmationOutcome.ProceedAlways,
+          name: `Yes, and auto-accept edits`,
+          kind: 'allow_always',
+        },
+        {
+          optionId: ToolConfirmationOutcome.ProceedOnce,
+          name: `Yes, and manually approve edits`,
+          kind: 'allow_once',
+        },
+        {
+          optionId: ToolConfirmationOutcome.Cancel,
+          name: `No, keep planning (esc)`,
+          kind: 'reject_once',
+        },
+      ];
+    default: {
+      const unreachable: never = confirmation;
+      throw new Error(`Unexpected: ${unreachable}`);
+    }
+  }
+}

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

@@ -0,0 +1,525 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SubAgentTracker } from './SubAgentTracker.js';
+import type { SessionContext } from './types.js';
+import type {
+  Config,
+  ToolRegistry,
+  SubAgentEventEmitter,
+  SubAgentToolCallEvent,
+  SubAgentToolResultEvent,
+  SubAgentApprovalRequestEvent,
+  ToolEditConfirmationDetails,
+  ToolInfoConfirmationDetails,
+} from '@qwen-code/qwen-code-core';
+import {
+  SubAgentEventType,
+  ToolConfirmationOutcome,
+  TodoWriteTool,
+} from '@qwen-code/qwen-code-core';
+import type * as acp from '../acp.js';
+import { EventEmitter } from 'node:events';
+
+// Helper to create a mock SubAgentToolCallEvent with required fields
+function createToolCallEvent(
+  overrides: Partial<SubAgentToolCallEvent> & { name: string; callId: string },
+): SubAgentToolCallEvent {
+  return {
+    subagentId: 'test-subagent',
+    round: 1,
+    timestamp: Date.now(),
+    description: `Calling ${overrides.name}`,
+    args: {},
+    ...overrides,
+  };
+}
+
+// Helper to create a mock SubAgentToolResultEvent with required fields
+function createToolResultEvent(
+  overrides: Partial<SubAgentToolResultEvent> & {
+    name: string;
+    callId: string;
+    success: boolean;
+  },
+): SubAgentToolResultEvent {
+  return {
+    subagentId: 'test-subagent',
+    round: 1,
+    timestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+// Helper to create a mock SubAgentApprovalRequestEvent with required fields
+function createApprovalEvent(
+  overrides: Partial<SubAgentApprovalRequestEvent> & {
+    name: string;
+    callId: string;
+    confirmationDetails: SubAgentApprovalRequestEvent['confirmationDetails'];
+    respond: SubAgentApprovalRequestEvent['respond'];
+  },
+): SubAgentApprovalRequestEvent {
+  return {
+    subagentId: 'test-subagent',
+    round: 1,
+    timestamp: Date.now(),
+    description: `Awaiting approval for ${overrides.name}`,
+    ...overrides,
+  };
+}
+
+// Helper to create edit confirmation details
+function createEditConfirmation(
+  overrides: Partial<Omit<ToolEditConfirmationDetails, 'onConfirm' | 'type'>>,
+): Omit<ToolEditConfirmationDetails, 'onConfirm'> {
+  return {
+    type: 'edit',
+    title: 'Edit file',
+    fileName: '/test.ts',
+    filePath: '/test.ts',
+    fileDiff: '',
+    originalContent: '',
+    newContent: '',
+    ...overrides,
+  };
+}
+
+// Helper to create info confirmation details
+function createInfoConfirmation(
+  overrides?: Partial<Omit<ToolInfoConfirmationDetails, 'onConfirm' | 'type'>>,
+): Omit<ToolInfoConfirmationDetails, 'onConfirm'> {
+  return {
+    type: 'info',
+    title: 'Tool requires approval',
+    prompt: 'Allow this action?',
+    ...overrides,
+  };
+}
+
+describe('SubAgentTracker', () => {
+  let mockContext: SessionContext;
+  let mockClient: acp.Client;
+  let sendUpdateSpy: ReturnType<typeof vi.fn>;
+  let requestPermissionSpy: ReturnType<typeof vi.fn>;
+  let tracker: SubAgentTracker;
+  let eventEmitter: SubAgentEventEmitter;
+  let abortController: AbortController;
+
+  beforeEach(() => {
+    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
+    requestPermissionSpy = vi.fn().mockResolvedValue({
+      outcome: { optionId: ToolConfirmationOutcome.ProceedOnce },
+    });
+
+    const mockToolRegistry = {
+      getTool: vi.fn().mockReturnValue(null),
+    } as unknown as ToolRegistry;
+
+    mockContext = {
+      sessionId: 'test-session-id',
+      config: {
+        getToolRegistry: () => mockToolRegistry,
+      } as unknown as Config,
+      sendUpdate: sendUpdateSpy,
+    };
+
+    mockClient = {
+      requestPermission: requestPermissionSpy,
+    } as unknown as acp.Client;
+
+    tracker = new SubAgentTracker(mockContext, mockClient);
+    eventEmitter = new EventEmitter() as unknown as SubAgentEventEmitter;
+    abortController = new AbortController();
+  });
+
+  describe('setup', () => {
+    it('should return cleanup function', () => {
+      const cleanups = tracker.setup(eventEmitter, abortController.signal);
+
+      expect(cleanups).toHaveLength(1);
+      expect(typeof cleanups[0]).toBe('function');
+    });
+
+    it('should register event listeners', () => {
+      const onSpy = vi.spyOn(eventEmitter, 'on');
+
+      tracker.setup(eventEmitter, abortController.signal);
+
+      expect(onSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_CALL,
+        expect.any(Function),
+      );
+      expect(onSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_RESULT,
+        expect.any(Function),
+      );
+      expect(onSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_WAITING_APPROVAL,
+        expect.any(Function),
+      );
+    });
+
+    it('should remove event listeners on cleanup', () => {
+      const offSpy = vi.spyOn(eventEmitter, 'off');
+      const cleanups = tracker.setup(eventEmitter, abortController.signal);
+
+      cleanups[0]();
+
+      expect(offSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_CALL,
+        expect.any(Function),
+      );
+      expect(offSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_RESULT,
+        expect.any(Function),
+      );
+      expect(offSpy).toHaveBeenCalledWith(
+        SubAgentEventType.TOOL_WAITING_APPROVAL,
+        expect.any(Function),
+      );
+    });
+  });
+
+  describe('tool call handling', () => {
+    it('should emit tool_call on TOOL_CALL event', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const event = createToolCallEvent({
+        name: 'read_file',
+        callId: 'call-123',
+        args: { path: '/test.ts' },
+        description: 'Reading file',
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+
+      // Allow async operations to complete
+      await vi.waitFor(() => {
+        expect(sendUpdateSpy).toHaveBeenCalled();
+      });
+
+      // ToolCallEmitter resolves metadata from registry - uses toolName when tool not found
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call',
+          toolCallId: 'call-123',
+          status: 'in_progress',
+          title: 'read_file',
+          content: [],
+          locations: [],
+          kind: 'other',
+          rawInput: { path: '/test.ts' },
+        }),
+      );
+    });
+
+    it('should skip tool_call for TodoWriteTool', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const event = createToolCallEvent({
+        name: TodoWriteTool.Name,
+        callId: 'call-todo',
+        args: { todos: [] },
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+
+      // Give time for any async operation
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not emit when aborted', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+      abortController.abort();
+
+      const event = createToolCallEvent({
+        name: 'read_file',
+        callId: 'call-123',
+        args: {},
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('tool result handling', () => {
+    it('should emit tool_call_update on TOOL_RESULT event', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      // First emit tool call to store state
+      eventEmitter.emit(
+        SubAgentEventType.TOOL_CALL,
+        createToolCallEvent({
+          name: 'read_file',
+          callId: 'call-123',
+          args: { path: '/test.ts' },
+        }),
+      );
+
+      // Then emit result
+      const resultEvent = createToolResultEvent({
+        name: 'read_file',
+        callId: 'call-123',
+        success: true,
+        resultDisplay: 'File contents',
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+
+      await vi.waitFor(() => {
+        expect(sendUpdateSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            sessionUpdate: 'tool_call_update',
+            toolCallId: 'call-123',
+            status: 'completed',
+          }),
+        );
+      });
+    });
+
+    it('should emit failed status on unsuccessful result', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const resultEvent = createToolResultEvent({
+        name: 'read_file',
+        callId: 'call-fail',
+        success: false,
+        resultDisplay: undefined,
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+
+      await vi.waitFor(() => {
+        expect(sendUpdateSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            sessionUpdate: 'tool_call_update',
+            status: 'failed',
+          }),
+        );
+      });
+    });
+
+    it('should emit plan update for TodoWriteTool results', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      // Store args via tool call
+      eventEmitter.emit(
+        SubAgentEventType.TOOL_CALL,
+        createToolCallEvent({
+          name: TodoWriteTool.Name,
+          callId: 'call-todo',
+          args: {
+            todos: [{ id: '1', content: 'Task 1', status: 'pending' }],
+          },
+        }),
+      );
+
+      // Emit result with todo_list display
+      const resultEvent = createToolResultEvent({
+        name: TodoWriteTool.Name,
+        callId: 'call-todo',
+        success: true,
+        resultDisplay: JSON.stringify({
+          type: 'todo_list',
+          todos: [{ id: '1', content: 'Task 1', status: 'completed' }],
+        }),
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
+
+      await vi.waitFor(() => {
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'plan',
+          entries: [
+            { content: 'Task 1', priority: 'medium', status: 'completed' },
+          ],
+        });
+      });
+    });
+
+    it('should clean up state after result', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      eventEmitter.emit(
+        SubAgentEventType.TOOL_CALL,
+        createToolCallEvent({
+          name: 'test_tool',
+          callId: 'call-cleanup',
+          args: { test: true },
+        }),
+      );
+
+      eventEmitter.emit(
+        SubAgentEventType.TOOL_RESULT,
+        createToolResultEvent({
+          name: 'test_tool',
+          callId: 'call-cleanup',
+          success: true,
+        }),
+      );
+
+      // Emit another result for same callId - should not have stored args
+      sendUpdateSpy.mockClear();
+      eventEmitter.emit(
+        SubAgentEventType.TOOL_RESULT,
+        createToolResultEvent({
+          name: 'test_tool',
+          callId: 'call-cleanup',
+          success: true,
+        }),
+      );
+
+      await vi.waitFor(() => {
+        expect(sendUpdateSpy).toHaveBeenCalled();
+      });
+
+      // Second call should not have args from first call
+      // (state was cleaned up)
+    });
+  });
+
+  describe('approval handling', () => {
+    it('should request permission from client', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const respondSpy = vi.fn().mockResolvedValue(undefined);
+      const event = createApprovalEvent({
+        name: 'edit_file',
+        callId: 'call-edit',
+        description: 'Editing file',
+        confirmationDetails: createEditConfirmation({
+          fileName: '/test.ts',
+          originalContent: 'old',
+          newContent: 'new',
+        }),
+        respond: respondSpy,
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+
+      await vi.waitFor(() => {
+        expect(requestPermissionSpy).toHaveBeenCalled();
+      });
+
+      expect(requestPermissionSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionId: 'test-session-id',
+          toolCall: expect.objectContaining({
+            toolCallId: 'call-edit',
+            status: 'pending',
+            content: [
+              {
+                type: 'diff',
+                path: '/test.ts',
+                oldText: 'old',
+                newText: 'new',
+              },
+            ],
+          }),
+        }),
+      );
+    });
+
+    it('should respond to subagent with permission outcome', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const respondSpy = vi.fn().mockResolvedValue(undefined);
+      const event = createApprovalEvent({
+        name: 'test_tool',
+        callId: 'call-123',
+        confirmationDetails: createInfoConfirmation(),
+        respond: respondSpy,
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+
+      await vi.waitFor(() => {
+        expect(respondSpy).toHaveBeenCalledWith(
+          ToolConfirmationOutcome.ProceedOnce,
+        );
+      });
+    });
+
+    it('should cancel on permission request failure', async () => {
+      requestPermissionSpy.mockRejectedValue(new Error('Network error'));
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const respondSpy = vi.fn().mockResolvedValue(undefined);
+      const event = createApprovalEvent({
+        name: 'test_tool',
+        callId: 'call-123',
+        confirmationDetails: createInfoConfirmation(),
+        respond: respondSpy,
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+
+      await vi.waitFor(() => {
+        expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
+      });
+    });
+
+    it('should handle cancelled outcome from client', async () => {
+      requestPermissionSpy.mockResolvedValue({
+        outcome: { outcome: 'cancelled' },
+      });
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const respondSpy = vi.fn().mockResolvedValue(undefined);
+      const event = createApprovalEvent({
+        name: 'test_tool',
+        callId: 'call-123',
+        confirmationDetails: createInfoConfirmation(),
+        respond: respondSpy,
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+
+      await vi.waitFor(() => {
+        expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
+      });
+    });
+  });
+
+  describe('permission options', () => {
+    it('should include "Allow All Edits" for edit type', async () => {
+      tracker.setup(eventEmitter, abortController.signal);
+
+      const event = createApprovalEvent({
+        name: 'edit_file',
+        callId: 'call-123',
+        confirmationDetails: createEditConfirmation({
+          fileName: '/test.ts',
+          originalContent: '',
+          newContent: 'new',
+        }),
+        respond: vi.fn(),
+      });
+
+      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
+
+      await vi.waitFor(() => {
+        expect(requestPermissionSpy).toHaveBeenCalled();
+      });
+
+      const call = requestPermissionSpy.mock.calls[0][0];
+      expect(call.options).toContainEqual(
+        expect.objectContaining({
+          optionId: ToolConfirmationOutcome.ProceedAlways,
+          name: 'Allow All Edits',
+        }),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,318 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  SubAgentEventEmitter,
+  SubAgentToolCallEvent,
+  SubAgentToolResultEvent,
+  SubAgentApprovalRequestEvent,
+  ToolCallConfirmationDetails,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
+} from '@qwen-code/qwen-code-core';
+import {
+  SubAgentEventType,
+  ToolConfirmationOutcome,
+} from '@qwen-code/qwen-code-core';
+import { z } from 'zod';
+import type { SessionContext } from './types.js';
+import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
+import type * as acp from '../acp.js';
+
+/**
+ * Permission option kind type matching ACP schema.
+ */
+type PermissionKind =
+  | 'allow_once'
+  | 'reject_once'
+  | 'allow_always'
+  | 'reject_always';
+
+/**
+ * Configuration for permission options displayed to users.
+ */
+interface PermissionOptionConfig {
+  optionId: ToolConfirmationOutcome;
+  name: string;
+  kind: PermissionKind;
+}
+
+const basicPermissionOptions: readonly PermissionOptionConfig[] = [
+  {
+    optionId: ToolConfirmationOutcome.ProceedOnce,
+    name: 'Allow',
+    kind: 'allow_once',
+  },
+  {
+    optionId: ToolConfirmationOutcome.Cancel,
+    name: 'Reject',
+    kind: 'reject_once',
+  },
+] as const;
+
+/**
+ * Tracks and emits events for sub-agent tool calls within TaskTool execution.
+ *
+ * Uses the unified ToolCallEmitter for consistency with normal flow
+ * and history replay. Also handles permission requests for tools that
+ * require user approval.
+ */
+export class SubAgentTracker {
+  private readonly toolCallEmitter: ToolCallEmitter;
+  private readonly toolStates = new Map<
+    string,
+    {
+      tool?: AnyDeclarativeTool;
+      invocation?: AnyToolInvocation;
+      args?: Record<string, unknown>;
+    }
+  >();
+
+  constructor(
+    private readonly ctx: SessionContext,
+    private readonly client: acp.Client,
+  ) {
+    this.toolCallEmitter = new ToolCallEmitter(ctx);
+  }
+
+  /**
+   * Sets up event listeners for a sub-agent's tool events.
+   *
+   * @param eventEmitter - The SubAgentEventEmitter from TaskTool
+   * @param abortSignal - Signal to abort tracking if parent is cancelled
+   * @returns Array of cleanup functions to remove listeners
+   */
+  setup(
+    eventEmitter: SubAgentEventEmitter,
+    abortSignal: AbortSignal,
+  ): Array<() => void> {
+    const onToolCall = this.createToolCallHandler(abortSignal);
+    const onToolResult = this.createToolResultHandler(abortSignal);
+    const onApproval = this.createApprovalHandler(abortSignal);
+
+    eventEmitter.on(SubAgentEventType.TOOL_CALL, onToolCall);
+    eventEmitter.on(SubAgentEventType.TOOL_RESULT, onToolResult);
+    eventEmitter.on(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
+
+    return [
+      () => {
+        eventEmitter.off(SubAgentEventType.TOOL_CALL, onToolCall);
+        eventEmitter.off(SubAgentEventType.TOOL_RESULT, onToolResult);
+        eventEmitter.off(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
+        // Clean up any remaining states
+        this.toolStates.clear();
+      },
+    ];
+  }
+
+  /**
+   * Creates a handler for tool call start events.
+   */
+  private createToolCallHandler(
+    abortSignal: AbortSignal,
+  ): (...args: unknown[]) => void {
+    return (...args: unknown[]) => {
+      const event = args[0] as SubAgentToolCallEvent;
+      if (abortSignal.aborted) return;
+
+      // Look up tool and build invocation for metadata
+      const toolRegistry = this.ctx.config.getToolRegistry();
+      const tool = toolRegistry.getTool(event.name);
+      let invocation: AnyToolInvocation | undefined;
+
+      if (tool) {
+        try {
+          invocation = tool.build(event.args);
+        } catch (e) {
+          // If building fails, continue with defaults
+          console.warn(`Failed to build subagent tool ${event.name}:`, e);
+        }
+      }
+
+      // Store tool, invocation, and args for result handling
+      this.toolStates.set(event.callId, {
+        tool,
+        invocation,
+        args: event.args,
+      });
+
+      // Use unified emitter - handles TodoWriteTool skipping internally
+      void this.toolCallEmitter.emitStart({
+        toolName: event.name,
+        callId: event.callId,
+        args: event.args,
+      });
+    };
+  }
+
+  /**
+   * Creates a handler for tool result events.
+   */
+  private createToolResultHandler(
+    abortSignal: AbortSignal,
+  ): (...args: unknown[]) => void {
+    return (...args: unknown[]) => {
+      const event = args[0] as SubAgentToolResultEvent;
+      if (abortSignal.aborted) return;
+
+      const state = this.toolStates.get(event.callId);
+
+      // Use unified emitter - handles TodoWriteTool plan updates internally
+      void this.toolCallEmitter.emitResult({
+        toolName: event.name,
+        callId: event.callId,
+        success: event.success,
+        message: event.responseParts ?? [],
+        resultDisplay: event.resultDisplay,
+        args: state?.args,
+      });
+
+      // Clean up state
+      this.toolStates.delete(event.callId);
+    };
+  }
+
+  /**
+   * Creates a handler for tool approval request events.
+   */
+  private createApprovalHandler(
+    abortSignal: AbortSignal,
+  ): (...args: unknown[]) => Promise<void> {
+    return async (...args: unknown[]) => {
+      const event = args[0] as SubAgentApprovalRequestEvent;
+      if (abortSignal.aborted) return;
+
+      const state = this.toolStates.get(event.callId);
+      const content: acp.ToolCallContent[] = [];
+
+      // Handle edit confirmation type - show diff
+      if (event.confirmationDetails.type === 'edit') {
+        const editDetails = event.confirmationDetails as unknown as {
+          type: 'edit';
+          fileName: string;
+          originalContent: string | null;
+          newContent: string;
+        };
+        content.push({
+          type: 'diff',
+          path: editDetails.fileName,
+          oldText: editDetails.originalContent ?? '',
+          newText: editDetails.newContent,
+        });
+      }
+
+      // Build permission request
+      const fullConfirmationDetails = {
+        ...event.confirmationDetails,
+        onConfirm: async () => {
+          // Placeholder - actual response handled via event.respond
+        },
+      } as unknown as ToolCallConfirmationDetails;
+
+      const { title, locations, kind } =
+        this.toolCallEmitter.resolveToolMetadata(event.name, state?.args);
+
+      const params: acp.RequestPermissionRequest = {
+        sessionId: this.ctx.sessionId,
+        options: this.toPermissionOptions(fullConfirmationDetails),
+        toolCall: {
+          toolCallId: event.callId,
+          status: 'pending',
+          title,
+          content,
+          locations,
+          kind,
+          rawInput: state?.args,
+        },
+      };
+
+      try {
+        // Request permission from client
+        const output = await this.client.requestPermission(params);
+        const outcome =
+          output.outcome.outcome === 'cancelled'
+            ? ToolConfirmationOutcome.Cancel
+            : z
+                .nativeEnum(ToolConfirmationOutcome)
+                .parse(output.outcome.optionId);
+
+        // Respond to subagent with the outcome
+        await event.respond(outcome);
+      } catch (error) {
+        // If permission request fails, cancel the tool call
+        console.error(
+          `Permission request failed for subagent tool ${event.name}:`,
+          error,
+        );
+        await event.respond(ToolConfirmationOutcome.Cancel);
+      }
+    };
+  }
+
+  /**
+   * Converts confirmation details to permission options for the client.
+   */
+  private toPermissionOptions(
+    confirmation: ToolCallConfirmationDetails,
+  ): acp.PermissionOption[] {
+    switch (confirmation.type) {
+      case 'edit':
+        return [
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlways,
+            name: 'Allow All Edits',
+            kind: 'allow_always',
+          },
+          ...basicPermissionOptions,
+        ];
+      case 'exec':
+        return [
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlways,
+            name: `Always Allow ${(confirmation as { rootCommand?: string }).rootCommand ?? 'command'}`,
+            kind: 'allow_always',
+          },
+          ...basicPermissionOptions,
+        ];
+      case 'mcp':
+        return [
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
+            name: `Always Allow ${(confirmation as { serverName?: string }).serverName ?? 'server'}`,
+            kind: 'allow_always',
+          },
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
+            name: `Always Allow ${(confirmation as { toolName?: string }).toolName ?? 'tool'}`,
+            kind: 'allow_always',
+          },
+          ...basicPermissionOptions,
+        ];
+      case 'info':
+        return [
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlways,
+            name: 'Always Allow',
+            kind: 'allow_always',
+          },
+          ...basicPermissionOptions,
+        ];
+      case 'plan':
+        return [
+          {
+            optionId: ToolConfirmationOutcome.ProceedAlways,
+            name: 'Always Allow Plans',
+            kind: 'allow_always',
+          },
+          ...basicPermissionOptions,
+        ];
+      default: {
+        // Fallback for unknown types
+        return [...basicPermissionOptions];
+      }
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { SessionContext } from '../types.js';
+import type * as acp from '../../acp.js';
+
+/**
+ * Abstract base class for all session event emitters.
+ * Provides common functionality and access to session context.
+ */
+export abstract class BaseEmitter {
+  constructor(protected readonly ctx: SessionContext) {}
+
+  /**
+   * Sends a session update to the ACP client.
+   */
+  protected async sendUpdate(update: acp.SessionUpdate): Promise<void> {
+    return this.ctx.sendUpdate(update);
+  }
+
+  /**
+   * Gets the session configuration.
+   */
+  protected get config() {
+    return this.ctx.config;
+  }
+
+  /**
+   * Gets the session ID.
+   */
+  protected get sessionId() {
+    return this.ctx.sessionId;
+  }
+}

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

@@ -0,0 +1,151 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MessageEmitter } from './MessageEmitter.js';
+import type { SessionContext } from '../types.js';
+import type { Config } from '@qwen-code/qwen-code-core';
+
+describe('MessageEmitter', () => {
+  let mockContext: SessionContext;
+  let sendUpdateSpy: ReturnType<typeof vi.fn>;
+  let emitter: MessageEmitter;
+
+  beforeEach(() => {
+    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
+    mockContext = {
+      sessionId: 'test-session-id',
+      config: {} as Config,
+      sendUpdate: sendUpdateSpy,
+    };
+    emitter = new MessageEmitter(mockContext);
+  });
+
+  describe('emitUserMessage', () => {
+    it('should send user_message_chunk update with text content', async () => {
+      await emitter.emitUserMessage('Hello, world!');
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: 'Hello, world!' },
+      });
+    });
+
+    it('should handle empty text', async () => {
+      await emitter.emitUserMessage('');
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: '' },
+      });
+    });
+
+    it('should handle multiline text', async () => {
+      const multilineText = 'Line 1\nLine 2\nLine 3';
+      await emitter.emitUserMessage(multilineText);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: multilineText },
+      });
+    });
+  });
+
+  describe('emitAgentMessage', () => {
+    it('should send agent_message_chunk update with text content', async () => {
+      await emitter.emitAgentMessage('I can help you with that.');
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'I can help you with that.' },
+      });
+    });
+  });
+
+  describe('emitAgentThought', () => {
+    it('should send agent_thought_chunk update with text content', async () => {
+      await emitter.emitAgentThought('Let me think about this...');
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Let me think about this...' },
+      });
+    });
+  });
+
+  describe('emitMessage', () => {
+    it('should emit user message when role is user', async () => {
+      await emitter.emitMessage('User input', 'user');
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: 'User input' },
+      });
+    });
+
+    it('should emit agent message when role is assistant and isThought is false', async () => {
+      await emitter.emitMessage('Agent response', 'assistant', false);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Agent response' },
+      });
+    });
+
+    it('should emit agent message when role is assistant and isThought is not provided', async () => {
+      await emitter.emitMessage('Agent response', 'assistant');
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Agent response' },
+      });
+    });
+
+    it('should emit agent thought when role is assistant and isThought is true', async () => {
+      await emitter.emitAgentThought('Thinking...');
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Thinking...' },
+      });
+    });
+
+    it('should ignore isThought when role is user', async () => {
+      // Even if isThought is true, user messages should still be user_message_chunk
+      await emitter.emitMessage('User input', 'user', true);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: 'User input' },
+      });
+    });
+  });
+
+  describe('multiple emissions', () => {
+    it('should handle multiple sequential emissions', async () => {
+      await emitter.emitUserMessage('First');
+      await emitter.emitAgentMessage('Second');
+      await emitter.emitAgentThought('Third');
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(3);
+      expect(sendUpdateSpy).toHaveBeenNthCalledWith(1, {
+        sessionUpdate: 'user_message_chunk',
+        content: { type: 'text', text: 'First' },
+      });
+      expect(sendUpdateSpy).toHaveBeenNthCalledWith(2, {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: 'Second' },
+      });
+      expect(sendUpdateSpy).toHaveBeenNthCalledWith(3, {
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Third' },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BaseEmitter } from './BaseEmitter.js';
+
+/**
+ * Handles emission of text message chunks (user, agent, thought).
+ *
+ * This emitter is responsible for sending message content to the ACP client
+ * in a consistent format, regardless of whether the message comes from
+ * normal flow, history replay, or other sources.
+ */
+export class MessageEmitter extends BaseEmitter {
+  /**
+   * Emits a user message chunk.
+   */
+  async emitUserMessage(text: string): Promise<void> {
+    await this.sendUpdate({
+      sessionUpdate: 'user_message_chunk',
+      content: { type: 'text', text },
+    });
+  }
+
+  /**
+   * Emits an agent message chunk.
+   */
+  async emitAgentMessage(text: string): Promise<void> {
+    await this.sendUpdate({
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text },
+    });
+  }
+
+  /**
+   * Emits an agent thought chunk.
+   */
+  async emitAgentThought(text: string): Promise<void> {
+    await this.sendUpdate({
+      sessionUpdate: 'agent_thought_chunk',
+      content: { type: 'text', text },
+    });
+  }
+
+  /**
+   * Emits a message chunk based on role and thought flag.
+   * This is the unified method that handles all message types.
+   *
+   * @param text - The message text content
+   * @param role - Whether this is a user or assistant message
+   * @param isThought - Whether this is an assistant thought (only applies to assistant role)
+   */
+  async emitMessage(
+    text: string,
+    role: 'user' | 'assistant',
+    isThought: boolean = false,
+  ): Promise<void> {
+    if (role === 'user') {
+      return this.emitUserMessage(text);
+    }
+    return isThought
+      ? this.emitAgentThought(text)
+      : this.emitAgentMessage(text);
+  }
+}

packages/cli/src/acp-integration/session/emitters/PlanEmitter.test.ts

@@ -0,0 +1,228 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PlanEmitter } from './PlanEmitter.js';
+import type { SessionContext, TodoItem } from '../types.js';
+import type { Config } from '@qwen-code/qwen-code-core';
+
+describe('PlanEmitter', () => {
+  let mockContext: SessionContext;
+  let sendUpdateSpy: ReturnType<typeof vi.fn>;
+  let emitter: PlanEmitter;
+
+  beforeEach(() => {
+    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
+    mockContext = {
+      sessionId: 'test-session-id',
+      config: {} as Config,
+      sendUpdate: sendUpdateSpy,
+    };
+    emitter = new PlanEmitter(mockContext);
+  });
+
+  describe('emitPlan', () => {
+    it('should send plan update with converted todo entries', async () => {
+      const todos: TodoItem[] = [
+        { id: '1', content: 'First task', status: 'pending' },
+        { id: '2', content: 'Second task', status: 'in_progress' },
+        { id: '3', content: 'Third task', status: 'completed' },
+      ];
+
+      await emitter.emitPlan(todos);
+
+      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'plan',
+        entries: [
+          { content: 'First task', priority: 'medium', status: 'pending' },
+          { content: 'Second task', priority: 'medium', status: 'in_progress' },
+          { content: 'Third task', priority: 'medium', status: 'completed' },
+        ],
+      });
+    });
+
+    it('should handle empty todos array', async () => {
+      await emitter.emitPlan([]);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'plan',
+        entries: [],
+      });
+    });
+
+    it('should set default priority to medium for all entries', async () => {
+      const todos: TodoItem[] = [
+        { id: '1', content: 'Task', status: 'pending' },
+      ];
+
+      await emitter.emitPlan(todos);
+
+      const call = sendUpdateSpy.mock.calls[0][0];
+      expect(call.entries[0].priority).toBe('medium');
+    });
+  });
+
+  describe('extractTodos', () => {
+    describe('from resultDisplay object', () => {
+      it('should extract todos from valid todo_list object', () => {
+        const resultDisplay = {
+          type: 'todo_list',
+          todos: [
+            { id: '1', content: 'Task 1', status: 'pending' as const },
+            { id: '2', content: 'Task 2', status: 'completed' as const },
+          ],
+        };
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toEqual([
+          { id: '1', content: 'Task 1', status: 'pending' },
+          { id: '2', content: 'Task 2', status: 'completed' },
+        ]);
+      });
+
+      it('should return null for object without type todo_list', () => {
+        const resultDisplay = {
+          type: 'other',
+          todos: [],
+        };
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toBeNull();
+      });
+
+      it('should return null for object without todos array', () => {
+        const resultDisplay = {
+          type: 'todo_list',
+          items: [], // wrong key
+        };
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe('from resultDisplay JSON string', () => {
+      it('should extract todos from valid JSON string', () => {
+        const resultDisplay = JSON.stringify({
+          type: 'todo_list',
+          todos: [{ id: '1', content: 'Task', status: 'pending' }],
+        });
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toEqual([
+          { id: '1', content: 'Task', status: 'pending' },
+        ]);
+      });
+
+      it('should return null for invalid JSON string', () => {
+        const resultDisplay = 'not valid json';
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toBeNull();
+      });
+
+      it('should return null for JSON without todo_list type', () => {
+        const resultDisplay = JSON.stringify({
+          type: 'other',
+          data: {},
+        });
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe('from args fallback', () => {
+      it('should extract todos from args when resultDisplay is null', () => {
+        const args = {
+          todos: [{ id: '1', content: 'From args', status: 'pending' }],
+        };
+
+        const result = emitter.extractTodos(null, args);
+
+        expect(result).toEqual([
+          { id: '1', content: 'From args', status: 'pending' },
+        ]);
+      });
+
+      it('should extract todos from args when resultDisplay is undefined', () => {
+        const args = {
+          todos: [{ id: '1', content: 'From args', status: 'pending' }],
+        };
+
+        const result = emitter.extractTodos(undefined, args);
+
+        expect(result).toEqual([
+          { id: '1', content: 'From args', status: 'pending' },
+        ]);
+      });
+
+      it('should prefer resultDisplay over args', () => {
+        const resultDisplay = {
+          type: 'todo_list',
+          todos: [{ id: '1', content: 'From display', status: 'completed' }],
+        };
+        const args = {
+          todos: [{ id: '2', content: 'From args', status: 'pending' }],
+        };
+
+        const result = emitter.extractTodos(resultDisplay, args);
+
+        expect(result).toEqual([
+          { id: '1', content: 'From display', status: 'completed' },
+        ]);
+      });
+
+      it('should return null when args has no todos array', () => {
+        const args = { other: 'value' };
+
+        const result = emitter.extractTodos(null, args);
+
+        expect(result).toBeNull();
+      });
+
+      it('should return null when args.todos is not an array', () => {
+        const args = { todos: 'not an array' };
+
+        const result = emitter.extractTodos(null, args);
+
+        expect(result).toBeNull();
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should return null when both resultDisplay and args are undefined', () => {
+        const result = emitter.extractTodos(undefined, undefined);
+
+        expect(result).toBeNull();
+      });
+
+      it('should return null when resultDisplay is empty object', () => {
+        const result = emitter.extractTodos({});
+
+        expect(result).toBeNull();
+      });
+
+      it('should handle resultDisplay with todos but wrong type', () => {
+        const resultDisplay = {
+          type: 'not_todo_list',
+          todos: [{ id: '1', content: 'Task', status: 'pending' }],
+        };
+
+        const result = emitter.extractTodos(resultDisplay);
+
+        expect(result).toBeNull();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BaseEmitter } from './BaseEmitter.js';
+import type { TodoItem } from '../types.js';
+import type * as acp from '../../acp.js';
+
+/**
+ * Handles emission of plan/todo updates.
+ *
+ * This emitter is responsible for converting todo items to ACP plan entries
+ * and sending plan updates to the client. It also provides utilities for
+ * extracting todos from various sources (tool result displays, args, etc.).
+ */
+export class PlanEmitter extends BaseEmitter {
+  /**
+   * Emits a plan update with the given todo items.
+   *
+   * @param todos - Array of todo items to send as plan entries
+   */
+  async emitPlan(todos: TodoItem[]): Promise<void> {
+    const entries: acp.PlanEntry[] = todos.map((todo) => ({
+      content: todo.content,
+      priority: 'medium' as const, // Default priority since todos don't have priority
+      status: todo.status,
+    }));
+
+    await this.sendUpdate({
+      sessionUpdate: 'plan',
+      entries,
+    });
+  }
+
+  /**
+   * Extracts todos from tool result display or args.
+   * Tries multiple sources in priority order:
+   * 1. Result display object with type 'todo_list'
+   * 2. Result display as JSON string
+   * 3. Args with 'todos' array
+   *
+   * @param resultDisplay - The tool result display (object, string, or undefined)
+   * @param args - The tool call arguments (fallback source)
+   * @returns Array of todos if found, null otherwise
+   */
+  extractTodos(
+    resultDisplay: unknown,
+    args?: Record<string, unknown>,
+  ): TodoItem[] | null {
+    // Try resultDisplay first (final state from tool execution)
+    const fromDisplay = this.extractFromResultDisplay(resultDisplay);
+    if (fromDisplay) return fromDisplay;
+
+    // Fallback to args (initial state)
+    if (args && Array.isArray(args['todos'])) {
+      return args['todos'] as TodoItem[];
+    }
+
+    return null;
+  }
+
+  /**
+   * Extracts todos from a result display value.
+   * Handles both object and JSON string formats.
+   */
+  private extractFromResultDisplay(resultDisplay: unknown): TodoItem[] | null {
+    if (!resultDisplay) return null;
+
+    // Handle direct object with type 'todo_list'
+    if (typeof resultDisplay === 'object') {
+      const obj = resultDisplay as Record<string, unknown>;
+      if (obj['type'] === 'todo_list' && Array.isArray(obj['todos'])) {
+        return obj['todos'] as TodoItem[];
+      }
+    }
+
+    // Handle JSON string (from subagent events)
+    if (typeof resultDisplay === 'string') {
+      try {
+        const parsed = JSON.parse(resultDisplay) as Record<string, unknown>;
+        if (
+          parsed?.['type'] === 'todo_list' &&
+          Array.isArray(parsed['todos'])
+        ) {
+          return parsed['todos'] as TodoItem[];
+        }
+      } catch {
+        // Not JSON, ignore
+      }
+    }
+
+    return null;
+  }
+}

packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.test.ts

@@ -0,0 +1,662 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ToolCallEmitter } from './ToolCallEmitter.js';
+import type { SessionContext } from '../types.js';
+import type {
+  Config,
+  ToolRegistry,
+  AnyDeclarativeTool,
+  AnyToolInvocation,
+} from '@qwen-code/qwen-code-core';
+import { Kind, TodoWriteTool } from '@qwen-code/qwen-code-core';
+import type { Part } from '@google/genai';
+
+// Helper to create mock message parts for tests
+const createMockMessage = (text?: string): Part[] =>
+  text
+    ? [{ functionResponse: { name: 'test', response: { output: text } } }]
+    : [];
+
+describe('ToolCallEmitter', () => {
+  let mockContext: SessionContext;
+  let sendUpdateSpy: ReturnType<typeof vi.fn>;
+  let mockToolRegistry: ToolRegistry;
+  let emitter: ToolCallEmitter;
+
+  // Helper to create mock tool
+  const createMockTool = (
+    overrides: Partial<AnyDeclarativeTool> = {},
+  ): AnyDeclarativeTool =>
+    ({
+      name: 'test_tool',
+      kind: Kind.Other,
+      build: vi.fn().mockReturnValue({
+        getDescription: () => 'Test tool description',
+        toolLocations: () => [{ path: '/test/file.ts', line: 10 }],
+      } as unknown as AnyToolInvocation),
+      ...overrides,
+    }) as unknown as AnyDeclarativeTool;
+
+  beforeEach(() => {
+    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
+    mockToolRegistry = {
+      getTool: vi.fn().mockReturnValue(null),
+    } as unknown as ToolRegistry;
+
+    mockContext = {
+      sessionId: 'test-session-id',
+      config: {
+        getToolRegistry: () => mockToolRegistry,
+      } as unknown as Config,
+      sendUpdate: sendUpdateSpy,
+    };
+
+    emitter = new ToolCallEmitter(mockContext);
+  });
+
+  describe('emitStart', () => {
+    it('should emit tool_call update with basic params when tool not in registry', async () => {
+      const result = await emitter.emitStart({
+        toolName: 'unknown_tool',
+        callId: 'call-123',
+        args: { arg1: 'value1' },
+      });
+
+      expect(result).toBe(true);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call',
+        toolCallId: 'call-123',
+        status: 'in_progress',
+        title: 'unknown_tool', // Falls back to tool name
+        content: [],
+        locations: [],
+        kind: 'other',
+        rawInput: { arg1: 'value1' },
+      });
+    });
+
+    it('should emit tool_call with resolved metadata when tool is in registry', async () => {
+      const mockTool = createMockTool({ kind: Kind.Edit });
+      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+
+      const result = await emitter.emitStart({
+        toolName: 'edit_file',
+        callId: 'call-456',
+        args: { path: '/test.ts' },
+      });
+
+      expect(result).toBe(true);
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call',
+        toolCallId: 'call-456',
+        status: 'in_progress',
+        title: 'edit_file: Test tool description',
+        content: [],
+        locations: [{ path: '/test/file.ts', line: 10 }],
+        kind: 'edit',
+        rawInput: { path: '/test.ts' },
+      });
+    });
+
+    it('should skip emit for TodoWriteTool and return false', async () => {
+      const result = await emitter.emitStart({
+        toolName: TodoWriteTool.Name,
+        callId: 'call-todo',
+        args: { todos: [] },
+      });
+
+      expect(result).toBe(false);
+      expect(sendUpdateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should handle empty args', async () => {
+      await emitter.emitStart({
+        toolName: 'test_tool',
+        callId: 'call-empty',
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          rawInput: {},
+        }),
+      );
+    });
+
+    it('should fall back gracefully when tool build fails', async () => {
+      const mockTool = createMockTool();
+      vi.mocked(mockTool.build).mockImplementation(() => {
+        throw new Error('Build failed');
+      });
+      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+
+      await emitter.emitStart({
+        toolName: 'failing_tool',
+        callId: 'call-fail',
+        args: { invalid: true },
+      });
+
+      // Should use fallback values
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call',
+        toolCallId: 'call-fail',
+        status: 'in_progress',
+        title: 'failing_tool', // Fallback to tool name
+        content: [],
+        locations: [], // Fallback to empty
+        kind: 'other', // Fallback to other
+        rawInput: { invalid: true },
+      });
+    });
+  });
+
+  describe('emitResult', () => {
+    it('should emit tool_call_update with completed status on success', async () => {
+      await emitter.emitResult({
+        toolName: 'test_tool',
+        callId: 'call-123',
+        success: true,
+        message: createMockMessage('Tool completed successfully'),
+        resultDisplay: 'Tool completed successfully',
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call_update',
+          toolCallId: 'call-123',
+          status: 'completed',
+          rawOutput: 'Tool completed successfully',
+        }),
+      );
+    });
+
+    it('should emit tool_call_update with failed status on failure', async () => {
+      await emitter.emitResult({
+        toolName: 'test_tool',
+        callId: 'call-123',
+        success: false,
+        message: [],
+        error: new Error('Something went wrong'),
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call_update',
+        toolCallId: 'call-123',
+        status: 'failed',
+        content: [
+          {
+            type: 'content',
+            content: { type: 'text', text: 'Something went wrong' },
+          },
+        ],
+      });
+    });
+
+    it('should handle diff display format', async () => {
+      await emitter.emitResult({
+        toolName: 'edit_file',
+        callId: 'call-edit',
+        success: true,
+        message: [],
+        resultDisplay: {
+          fileName: '/test/file.ts',
+          originalContent: 'old content',
+          newContent: 'new content',
+        },
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call_update',
+          toolCallId: 'call-edit',
+          status: 'completed',
+          content: [
+            {
+              type: 'diff',
+              path: '/test/file.ts',
+              oldText: 'old content',
+              newText: 'new content',
+            },
+          ],
+        }),
+      );
+    });
+
+    it('should transform message parts to content', async () => {
+      await emitter.emitResult({
+        toolName: 'test_tool',
+        callId: 'call-123',
+        success: true,
+        message: [{ text: 'Some text output' }],
+        resultDisplay: 'raw output',
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionUpdate: 'tool_call_update',
+          toolCallId: 'call-123',
+          status: 'completed',
+          content: [
+            {
+              type: 'content',
+              content: { type: 'text', text: 'Some text output' },
+            },
+          ],
+          rawOutput: 'raw output',
+        }),
+      );
+    });
+
+    it('should handle empty message parts', async () => {
+      await emitter.emitResult({
+        toolName: 'test_tool',
+        callId: 'call-empty',
+        success: true,
+        message: [],
+      });
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call_update',
+        toolCallId: 'call-empty',
+        status: 'completed',
+        content: [],
+      });
+    });
+
+    describe('TodoWriteTool handling', () => {
+      it('should emit plan update instead of tool_call_update for TodoWriteTool', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo',
+          success: true,
+          message: [],
+          resultDisplay: {
+            type: 'todo_list',
+            todos: [
+              { id: '1', content: 'Task 1', status: 'pending' },
+              { id: '2', content: 'Task 2', status: 'in_progress' },
+            ],
+          },
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'plan',
+          entries: [
+            { content: 'Task 1', priority: 'medium', status: 'pending' },
+            { content: 'Task 2', priority: 'medium', status: 'in_progress' },
+          ],
+        });
+      });
+
+      it('should use args as fallback for TodoWriteTool todos', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo',
+          success: true,
+          message: [],
+          resultDisplay: null,
+          args: {
+            todos: [{ id: '1', content: 'From args', status: 'completed' }],
+          },
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'plan',
+          entries: [
+            { content: 'From args', priority: 'medium', status: 'completed' },
+          ],
+        });
+      });
+
+      it('should not emit anything for TodoWriteTool with empty todos', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo',
+          success: true,
+          message: [],
+          resultDisplay: { type: 'todo_list', todos: [] },
+        });
+
+        expect(sendUpdateSpy).not.toHaveBeenCalled();
+      });
+
+      it('should not emit anything for TodoWriteTool with no extractable todos', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo',
+          success: true,
+          message: [],
+          resultDisplay: 'Some string result',
+        });
+
+        expect(sendUpdateSpy).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('emitError', () => {
+    it('should emit tool_call_update with failed status and error message', async () => {
+      const error = new Error('Connection timeout');
+
+      await emitter.emitError('call-123', error);
+
+      expect(sendUpdateSpy).toHaveBeenCalledWith({
+        sessionUpdate: 'tool_call_update',
+        toolCallId: 'call-123',
+        status: 'failed',
+        content: [
+          {
+            type: 'content',
+            content: { type: 'text', text: 'Connection timeout' },
+          },
+        ],
+      });
+    });
+  });
+
+  describe('isTodoWriteTool', () => {
+    it('should return true for TodoWriteTool.Name', () => {
+      expect(emitter.isTodoWriteTool(TodoWriteTool.Name)).toBe(true);
+    });
+
+    it('should return false for other tool names', () => {
+      expect(emitter.isTodoWriteTool('read_file')).toBe(false);
+      expect(emitter.isTodoWriteTool('edit_file')).toBe(false);
+      expect(emitter.isTodoWriteTool('')).toBe(false);
+    });
+  });
+
+  describe('mapToolKind', () => {
+    it('should map all Kind values correctly', () => {
+      expect(emitter.mapToolKind(Kind.Read)).toBe('read');
+      expect(emitter.mapToolKind(Kind.Edit)).toBe('edit');
+      expect(emitter.mapToolKind(Kind.Delete)).toBe('delete');
+      expect(emitter.mapToolKind(Kind.Move)).toBe('move');
+      expect(emitter.mapToolKind(Kind.Search)).toBe('search');
+      expect(emitter.mapToolKind(Kind.Execute)).toBe('execute');
+      expect(emitter.mapToolKind(Kind.Think)).toBe('think');
+      expect(emitter.mapToolKind(Kind.Fetch)).toBe('fetch');
+      expect(emitter.mapToolKind(Kind.Other)).toBe('other');
+    });
+
+    it('should map exit_plan_mode tool to switch_mode kind', () => {
+      // exit_plan_mode uses Kind.Think internally, but should map to switch_mode per ACP spec
+      expect(emitter.mapToolKind(Kind.Think, 'exit_plan_mode')).toBe(
+        'switch_mode',
+      );
+    });
+
+    it('should not affect other tools with Kind.Think', () => {
+      // Other tools with Kind.Think should still map to think
+      expect(emitter.mapToolKind(Kind.Think, 'todo_write')).toBe('think');
+      expect(emitter.mapToolKind(Kind.Think, 'some_other_tool')).toBe('think');
+    });
+  });
+
+  describe('isExitPlanModeTool', () => {
+    it('should return true for exit_plan_mode tool name', () => {
+      expect(emitter.isExitPlanModeTool('exit_plan_mode')).toBe(true);
+    });
+
+    it('should return false for other tool names', () => {
+      expect(emitter.isExitPlanModeTool('read_file')).toBe(false);
+      expect(emitter.isExitPlanModeTool('edit_file')).toBe(false);
+      expect(emitter.isExitPlanModeTool('todo_write')).toBe(false);
+      expect(emitter.isExitPlanModeTool('')).toBe(false);
+    });
+  });
+
+  describe('resolveToolMetadata', () => {
+    it('should return defaults when tool not found', () => {
+      const metadata = emitter.resolveToolMetadata('unknown_tool', {
+        arg: 'value',
+      });
+
+      expect(metadata).toEqual({
+        title: 'unknown_tool',
+        locations: [],
+        kind: 'other',
+      });
+    });
+
+    it('should return tool metadata when tool found and built successfully', () => {
+      const mockTool = createMockTool({ kind: Kind.Search });
+      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+
+      const metadata = emitter.resolveToolMetadata('search_tool', {
+        query: 'test',
+      });
+
+      expect(metadata).toEqual({
+        title: 'search_tool: Test tool description',
+        locations: [{ path: '/test/file.ts', line: 10 }],
+        kind: 'search',
+      });
+    });
+  });
+
+  describe('integration: consistent behavior across flows', () => {
+    it('should handle the same params consistently regardless of source', async () => {
+      // This test verifies that the emitter produces consistent output
+      // whether called from normal flow, replay, or subagent
+
+      const params = {
+        toolName: 'read_file',
+        callId: 'consistent-call',
+        args: { path: '/test.ts' },
+      };
+
+      // First call (e.g., from normal flow)
+      await emitter.emitStart(params);
+      const firstCall = sendUpdateSpy.mock.calls[0][0];
+
+      // Reset and call again (e.g., from replay)
+      sendUpdateSpy.mockClear();
+      await emitter.emitStart(params);
+      const secondCall = sendUpdateSpy.mock.calls[0][0];
+
+      // Both should produce identical output
+      expect(firstCall).toEqual(secondCall);
+    });
+  });
+
+  describe('fixes verification', () => {
+    describe('Fix 2: functionResponse parts are stringified', () => {
+      it('should stringify functionResponse parts in message', async () => {
+        await emitter.emitResult({
+          toolName: 'test_tool',
+          callId: 'call-func',
+          success: true,
+          message: [
+            {
+              functionResponse: {
+                name: 'test',
+                response: { output: 'test output' },
+              },
+            },
+          ],
+          resultDisplay: { unknownField: 'value', nested: { data: 123 } },
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            sessionUpdate: 'tool_call_update',
+            toolCallId: 'call-func',
+            status: 'completed',
+            content: [
+              {
+                type: 'content',
+                content: {
+                  type: 'text',
+                  text: '{"output":"test output"}',
+                },
+              },
+            ],
+            rawOutput: { unknownField: 'value', nested: { data: 123 } },
+          }),
+        );
+      });
+    });
+
+    describe('Fix 3: rawOutput is included in emitResult', () => {
+      it('should include rawOutput when resultDisplay is provided', async () => {
+        await emitter.emitResult({
+          toolName: 'test_tool',
+          callId: 'call-extra',
+          success: true,
+          message: [{ text: 'Result text' }],
+          resultDisplay: 'Result text',
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            sessionUpdate: 'tool_call_update',
+            toolCallId: 'call-extra',
+            status: 'completed',
+            rawOutput: 'Result text',
+          }),
+        );
+      });
+
+      it('should not include rawOutput when resultDisplay is undefined', async () => {
+        await emitter.emitResult({
+          toolName: 'test_tool',
+          callId: 'call-null',
+          success: true,
+          message: [],
+        });
+
+        const call = sendUpdateSpy.mock.calls[0][0];
+        expect(call.rawOutput).toBeUndefined();
+      });
+    });
+
+    describe('Fix 5: Line null mapping in resolveToolMetadata', () => {
+      it('should map undefined line to null in locations', () => {
+        const mockTool = createMockTool();
+        // Override toolLocations to return undefined line
+        vi.mocked(mockTool.build).mockReturnValue({
+          getDescription: () => 'Description',
+          toolLocations: () => [
+            { path: '/file1.ts', line: 10 },
+            { path: '/file2.ts', line: undefined },
+            { path: '/file3.ts' }, // no line property
+          ],
+        } as unknown as AnyToolInvocation);
+        vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
+
+        const metadata = emitter.resolveToolMetadata('test_tool', {
+          arg: 'value',
+        });
+
+        expect(metadata.locations).toEqual([
+          { path: '/file1.ts', line: 10 },
+          { path: '/file2.ts', line: null },
+          { path: '/file3.ts', line: null },
+        ]);
+      });
+    });
+
+    describe('Fix 6: Empty plan emission when args has todos', () => {
+      it('should emit empty plan when args had todos but result has none', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo-empty',
+          success: true,
+          message: [],
+          resultDisplay: null, // No result display
+          args: {
+            todos: [], // Empty array in args
+          },
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'plan',
+          entries: [],
+        });
+      });
+
+      it('should emit empty plan when result todos is empty but args had todos', async () => {
+        await emitter.emitResult({
+          toolName: TodoWriteTool.Name,
+          callId: 'call-todo-cleared',
+          success: true,
+          message: [],
+          resultDisplay: {
+            type: 'todo_list',
+            todos: [], // Empty result
+          },
+          args: {
+            todos: [{ id: '1', content: 'Was here', status: 'pending' }],
+          },
+        });
+
+        // Should still emit empty plan (result takes precedence but we emit empty)
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'plan',
+          entries: [],
+        });
+      });
+    });
+
+    describe('Message transformation', () => {
+      it('should transform text parts from message', async () => {
+        await emitter.emitResult({
+          toolName: 'test_tool',
+          callId: 'call-text',
+          success: true,
+          message: [{ text: 'Text content from message' }],
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith({
+          sessionUpdate: 'tool_call_update',
+          toolCallId: 'call-text',
+          status: 'completed',
+          content: [
+            {
+              type: 'content',
+              content: { type: 'text', text: 'Text content from message' },
+            },
+          ],
+        });
+      });
+
+      it('should transform functionResponse parts from message', async () => {
+        await emitter.emitResult({
+          toolName: 'test_tool',
+          callId: 'call-func-resp',
+          success: true,
+          message: [
+            {
+              functionResponse: {
+                name: 'test_tool',
+                response: { output: 'Function output' },
+              },
+            },
+          ],
+          resultDisplay: 'raw result',
+        });
+
+        expect(sendUpdateSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            sessionUpdate: 'tool_call_update',
+            toolCallId: 'call-func-resp',
+            status: 'completed',
+            content: [
+              {
+                type: 'content',
+                content: { type: 'text', text: '{"output":"Function output"}' },
+              },
+            ],
+            rawOutput: 'raw result',
+          }),
+        );
+      });
+    });
+  });
+});

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

@@ -0,0 +1,291 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BaseEmitter } from './BaseEmitter.js';
+import { PlanEmitter } from './PlanEmitter.js';
+import type {
+  SessionContext,
+  ToolCallStartParams,
+  ToolCallResultParams,
+  ResolvedToolMetadata,
+} from '../types.js';
+import type * as acp from '../../acp.js';
+import type { Part } from '@google/genai';
+import {
+  TodoWriteTool,
+  Kind,
+  ExitPlanModeTool,
+} from '@qwen-code/qwen-code-core';
+
+/**
+ * Unified tool call event emitter.
+ *
+ * Handles tool_call and tool_call_update for ALL flows:
+ * - Normal tool execution in runTool()
+ * - History replay in HistoryReplayer
+ * - SubAgent tool tracking in SubAgentTracker
+ *
+ * This ensures consistent behavior across all tool event sources,
+ * including special handling for tools like TodoWriteTool.
+ */
+export class ToolCallEmitter extends BaseEmitter {
+  private readonly planEmitter: PlanEmitter;
+
+  constructor(ctx: SessionContext) {
+    super(ctx);
+    this.planEmitter = new PlanEmitter(ctx);
+  }
+
+  /**
+   * Emits a tool call start event.
+   *
+   * @param params - Tool call start parameters
+   * @returns true if event was emitted, false if skipped (e.g., TodoWriteTool)
+   */
+  async emitStart(params: ToolCallStartParams): Promise<boolean> {
+    // Skip tool_call for TodoWriteTool - plan updates sent on result
+    if (this.isTodoWriteTool(params.toolName)) {
+      return false;
+    }
+
+    const { title, locations, kind } = this.resolveToolMetadata(
+      params.toolName,
+      params.args,
+    );
+
+    await this.sendUpdate({
+      sessionUpdate: 'tool_call',
+      toolCallId: params.callId,
+      status: 'in_progress',
+      title,
+      content: [],
+      locations,
+      kind,
+      rawInput: params.args ?? {},
+    });
+
+    return true;
+  }
+
+  /**
+   * Emits a tool call result event.
+   * Handles TodoWriteTool specially by routing to plan updates.
+   *
+   * @param params - Tool call result parameters
+   */
+  async emitResult(params: ToolCallResultParams): Promise<void> {
+    // Handle TodoWriteTool specially - send plan update instead
+    if (this.isTodoWriteTool(params.toolName)) {
+      const todos = this.planEmitter.extractTodos(
+        params.resultDisplay,
+        params.args,
+      );
+      // Match original behavior: send plan even if empty when args['todos'] exists
+      // This ensures the UI is updated even when all todos are removed
+      if (todos && todos.length > 0) {
+        await this.planEmitter.emitPlan(todos);
+      } else if (params.args && Array.isArray(params.args['todos'])) {
+        // Send empty plan when args had todos but result has none
+        await this.planEmitter.emitPlan([]);
+      }
+      return; // Skip tool_call_update for TodoWriteTool
+    }
+
+    // Determine content for the update
+    let contentArray: acp.ToolCallContent[] = [];
+
+    // Special case: diff result from edit tools (format from resultDisplay)
+    const diffContent = this.extractDiffContent(params.resultDisplay);
+    if (diffContent) {
+      contentArray = [diffContent];
+    } else if (params.error) {
+      // Error case: show error message
+      contentArray = [
+        {
+          type: 'content',
+          content: { type: 'text', text: params.error.message },
+        },
+      ];
+    } else {
+      // Normal case: transform message parts to ToolCallContent[]
+      contentArray = this.transformPartsToToolCallContent(params.message);
+    }
+
+    // Build the update
+    const update: Parameters<typeof this.sendUpdate>[0] = {
+      sessionUpdate: 'tool_call_update',
+      toolCallId: params.callId,
+      status: params.success ? 'completed' : 'failed',
+      content: contentArray,
+    };
+
+    // Add rawOutput from resultDisplay
+    if (params.resultDisplay !== undefined) {
+      (update as Record<string, unknown>)['rawOutput'] = params.resultDisplay;
+    }
+
+    await this.sendUpdate(update);
+  }
+
+  /**
+   * Emits a tool call error event.
+   * Use this for explicit error handling when not using emitResult.
+   *
+   * @param callId - The tool call ID
+   * @param error - The error that occurred
+   */
+  async emitError(callId: string, error: Error): Promise<void> {
+    await this.sendUpdate({
+      sessionUpdate: 'tool_call_update',
+      toolCallId: callId,
+      status: 'failed',
+      content: [
+        { type: 'content', content: { type: 'text', text: error.message } },
+      ],
+    });
+  }
+
+  // ==================== Public Utilities ====================
+
+  /**
+   * Checks if a tool name is the TodoWriteTool.
+   * Exposed for external use in components that need to check this.
+   */
+  isTodoWriteTool(toolName: string): boolean {
+    return toolName === TodoWriteTool.Name;
+  }
+
+  /**
+   * Checks if a tool name is the ExitPlanModeTool.
+   */
+  isExitPlanModeTool(toolName: string): boolean {
+    return toolName === ExitPlanModeTool.Name;
+  }
+
+  /**
+   * Resolves tool metadata from the registry.
+   * Falls back to defaults if tool not found or build fails.
+   *
+   * @param toolName - Name of the tool
+   * @param args - Tool call arguments (used to build invocation)
+   */
+  resolveToolMetadata(
+    toolName: string,
+    args?: Record<string, unknown>,
+  ): ResolvedToolMetadata {
+    const toolRegistry = this.config.getToolRegistry();
+    const tool = toolRegistry.getTool(toolName);
+
+    let title = tool?.displayName ?? toolName;
+    let locations: acp.ToolCallLocation[] = [];
+    let kind: acp.ToolKind = 'other';
+
+    if (tool && args) {
+      try {
+        const invocation = tool.build(args);
+        title = `${title}: ${invocation.getDescription()}`;
+        // Map locations to ensure line is null instead of undefined (for ACP consistency)
+        locations = invocation.toolLocations().map((loc) => ({
+          path: loc.path,
+          line: loc.line ?? null,
+        }));
+        // Pass tool name to handle special cases like exit_plan_mode -> switch_mode
+        kind = this.mapToolKind(tool.kind, toolName);
+      } catch {
+        // Use defaults on build failure
+      }
+    }
+
+    return { title, locations, kind };
+  }
+
+  /**
+   * Maps core Tool Kind enum to ACP ToolKind string literals.
+   *
+   * @param kind - The core Kind enum value
+   * @param toolName - Optional tool name to handle special cases like exit_plan_mode
+   */
+  mapToolKind(kind: Kind, toolName?: string): acp.ToolKind {
+    // Special case: exit_plan_mode uses 'switch_mode' kind per ACP spec
+    if (toolName && this.isExitPlanModeTool(toolName)) {
+      return 'switch_mode';
+    }
+
+    const kindMap: Record<Kind, acp.ToolKind> = {
+      [Kind.Read]: 'read',
+      [Kind.Edit]: 'edit',
+      [Kind.Delete]: 'delete',
+      [Kind.Move]: 'move',
+      [Kind.Search]: 'search',
+      [Kind.Execute]: 'execute',
+      [Kind.Think]: 'think',
+      [Kind.Fetch]: 'fetch',
+      [Kind.Other]: 'other',
+    };
+    return kindMap[kind] ?? 'other';
+  }
+
+  // ==================== Private Helpers ====================
+
+  /**
+   * Extracts diff content from resultDisplay if it's a diff type (edit tool result).
+   * Returns null if not a diff.
+   */
+  private extractDiffContent(
+    resultDisplay: unknown,
+  ): acp.ToolCallContent | null {
+    if (!resultDisplay || typeof resultDisplay !== 'object') return null;
+
+    const obj = resultDisplay as Record<string, unknown>;
+
+    // Check if this is a diff display (edit tool result)
+    if ('fileName' in obj && 'newContent' in obj) {
+      return {
+        type: 'diff',
+        path: obj['fileName'] as string,
+        oldText: (obj['originalContent'] as string) ?? '',
+        newText: obj['newContent'] as string,
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Transforms Part[] to ToolCallContent[].
+   * Extracts text from functionResponse parts and text parts.
+   */
+  private transformPartsToToolCallContent(
+    parts: Part[],
+  ): acp.ToolCallContent[] {
+    const result: acp.ToolCallContent[] = [];
+
+    for (const part of parts) {
+      // Handle text parts
+      if ('text' in part && part.text) {
+        result.push({
+          type: 'content',
+          content: { type: 'text', text: part.text },
+        });
+      }
+
+      // Handle functionResponse parts - stringify the response
+      if ('functionResponse' in part && part.functionResponse) {
+        try {
+          const responseText = JSON.stringify(part.functionResponse.response);
+          result.push({
+            type: 'content',
+            content: { type: 'text', text: responseText },
+          });
+        } catch {
+          // Ignore serialization errors
+        }
+      }
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export { BaseEmitter } from './BaseEmitter.js';
+export { MessageEmitter } from './MessageEmitter.js';
+export { PlanEmitter } from './PlanEmitter.js';
+export { ToolCallEmitter } from './ToolCallEmitter.js';

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

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Session module for ACP/Zed integration.
+ *
+ * This module provides a modular architecture for handling session events:
+ * - **Emitters**: Unified event emission (MessageEmitter, ToolCallEmitter, PlanEmitter)
+ * - **HistoryReplayer**: Replays session history using unified emitters
+ * - **SubAgentTracker**: Tracks sub-agent tool events using unified emitters
+ *
+ * The key benefit is that all event emission goes through the same emitters,
+ * ensuring consistency between normal flow, history replay, and sub-agent events.
+ */
+
+// Types
+export type {
+  SessionContext,
+  SessionUpdateSender,
+  ToolCallStartParams,
+  ToolCallResultParams,
+  TodoItem,
+  ResolvedToolMetadata,
+} from './types.js';
+
+// Emitters
+export { BaseEmitter } from './emitters/BaseEmitter.js';
+export { MessageEmitter } from './emitters/MessageEmitter.js';
+export { PlanEmitter } from './emitters/PlanEmitter.js';
+export { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
+
+// Components
+export { HistoryReplayer } from './HistoryReplayer.js';
+export { SubAgentTracker } from './SubAgentTracker.js';
+
+// Main Session class
+export { Session } from './Session.js';

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

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Config } from '@qwen-code/qwen-code-core';
+import type { Part } from '@google/genai';
+import type * as acp from '../acp.js';
+
+/**
+ * Interface for sending session updates to the ACP client.
+ * Implemented by Session class and used by all emitters.
+ */
+export interface SessionUpdateSender {
+  sendUpdate(update: acp.SessionUpdate): Promise<void>;
+}
+
+/**
+ * Session context shared across all emitters.
+ * Provides access to session state and configuration.
+ */
+export interface SessionContext extends SessionUpdateSender {
+  readonly sessionId: string;
+  readonly config: Config;
+}
+
+/**
+ * Parameters for emitting a tool call start event.
+ */
+export interface ToolCallStartParams {
+  /** Name of the tool being called */
+  toolName: string;
+  /** Unique identifier for this tool call */
+  callId: string;
+  /** Arguments passed to the tool */
+  args?: Record<string, unknown>;
+}
+
+/**
+ * Parameters for emitting a tool call result event.
+ */
+export interface ToolCallResultParams {
+  /** Name of the tool that was called */
+  toolName: string;
+  /** Unique identifier for this tool call */
+  callId: string;
+  /** Whether the tool execution succeeded */
+  success: boolean;
+  /** The response parts from tool execution (maps to content in update event) */
+  message: Part[];
+  /** Display result from tool execution (maps to rawOutput in update event) */
+  resultDisplay?: unknown;
+  /** Error if tool execution failed */
+  error?: Error;
+  /** Original args (fallback for TodoWriteTool todos extraction) */
+  args?: Record<string, unknown>;
+}
+
+/**
+ * Todo item structure for plan updates.
+ */
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+/**
+ * Resolved tool metadata from the registry.
+ */
+export interface ResolvedToolMetadata {
+  title: string;
+  locations: acp.ToolCallLocation[];
+  kind: acp.ToolKind;
+}

packages/cli/src/config/config.integration.test.ts

@@ -15,6 +15,7 @@ import type {
 import { Config } from '@qwen-code/qwen-code-core';
 import { http, HttpResponse } from 'msw';
 import { setupServer } from 'msw/node';
+import type { Settings } from './settings.js';
 
 export const server = setupServer();
 
@@ -73,12 +74,10 @@ describe('Configuration Integration Tests', () => {
     it('should load default file filtering settings', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
-        fileFilteringRespectGitIgnore: undefined, // Should default to true
       };
 
       const config = new Config(configParams);
@@ -89,9 +88,8 @@ describe('Configuration Integration Tests', () => {
     it('should load custom file filtering settings from configuration', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         fileFiltering: {
@@ -107,12 +105,10 @@ describe('Configuration Integration Tests', () => {
     it('should merge user and workspace file filtering settings', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
-        fileFilteringRespectGitIgnore: true,
       };
 
       const config = new Config(configParams);
@@ -125,9 +121,8 @@ describe('Configuration Integration Tests', () => {
     it('should handle partial configuration objects gracefully', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         fileFiltering: {
@@ -144,12 +139,10 @@ describe('Configuration Integration Tests', () => {
     it('should handle empty configuration objects gracefully', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
-        fileFilteringRespectGitIgnore: undefined,
       };
 
       const config = new Config(configParams);
@@ -161,9 +154,8 @@ describe('Configuration Integration Tests', () => {
     it('should handle missing configuration sections gracefully', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         // Missing fileFiltering configuration
@@ -180,12 +172,10 @@ describe('Configuration Integration Tests', () => {
     it('should handle a security-focused configuration', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
-        fileFilteringRespectGitIgnore: true,
       };
 
       const config = new Config(configParams);
@@ -196,9 +186,8 @@ describe('Configuration Integration Tests', () => {
     it('should handle a CI/CD environment configuration', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         fileFiltering: {
@@ -216,9 +205,8 @@ describe('Configuration Integration Tests', () => {
     it('should enable checkpointing when the setting is true', async () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         checkpointing: true,
@@ -234,9 +222,8 @@ describe('Configuration Integration Tests', () => {
     it('should have an empty array for extension context files by default', () => {
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
       };
@@ -248,9 +235,8 @@ describe('Configuration Integration Tests', () => {
       const contextFiles = ['/path/to/file1.txt', '/path/to/file2.js'];
       const configParams: ConfigParameters = {
         cwd: '/tmp',
-        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
         embeddingModel: 'test-embedding-model',
-        sandbox: false,
         targetDir: tempDir,
         debugMode: false,
         extensionContextFilePaths: contextFiles,
@@ -261,11 +247,11 @@ describe('Configuration Integration Tests', () => {
   });
 
   describe('Approval Mode Integration Tests', () => {
-    let parseArguments: typeof import('./config').parseArguments;
+    let parseArguments: typeof import('./config.js').parseArguments;
 
     beforeEach(async () => {
       // Import the argument parsing function for integration testing
-      const { parseArguments: parseArgs } = await import('./config');
+      const { parseArguments: parseArgs } = await import('./config.js');
       parseArguments = parseArgs;
     });
 

packages/cli/src/config/config.test.ts

@@ -535,7 +535,6 @@ describe('loadCliConfig', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -555,7 +554,6 @@ describe('loadCliConfig', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getShowMemoryUsage()).toBe(true);
@@ -572,7 +570,6 @@ describe('loadCliConfig', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getShowMemoryUsage()).toBe(false);
@@ -589,7 +586,6 @@ describe('loadCliConfig', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getShowMemoryUsage()).toBe(false);
@@ -606,7 +602,6 @@ describe('loadCliConfig', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getShowMemoryUsage()).toBe(true);
@@ -649,7 +644,6 @@ describe('loadCliConfig', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
         argv,
       );
       expect(config.getProxy()).toBeFalsy();
@@ -699,7 +693,6 @@ describe('loadCliConfig', () => {
             ExtensionStorage.getUserExtensionsDir(),
             argv.extensions,
           ),
-          'test-session',
           argv,
         );
         expect(config.getProxy()).toBe(expected);
@@ -717,7 +710,6 @@ describe('loadCliConfig', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
         argv,
       );
       expect(config.getProxy()).toBe('http://localhost:7890');
@@ -735,7 +727,6 @@ describe('loadCliConfig', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
         argv,
       );
       expect(config.getProxy()).toBe('http://localhost:7890');
@@ -769,7 +760,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(false);
@@ -786,7 +776,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -803,7 +792,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(false);
@@ -820,7 +808,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -837,7 +824,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(false);
@@ -854,7 +840,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -871,7 +856,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(false);
@@ -890,7 +874,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpEndpoint()).toBe(
@@ -916,7 +899,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpEndpoint()).toBe('http://cli.example.com');
@@ -933,7 +915,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpEndpoint()).toBe('http://localhost:4317');
@@ -952,7 +933,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryTarget()).toBe(
@@ -973,7 +953,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryTarget()).toBe('gcp');
@@ -990,7 +969,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryTarget()).toBe(
@@ -1009,7 +987,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -1026,7 +1003,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -1043,7 +1019,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -1060,7 +1035,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -1079,7 +1053,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -1098,7 +1071,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -1115,7 +1087,6 @@ describe('loadCliConfig telemetry', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
@@ -1197,12 +1168,10 @@ describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
     await loadCliConfig(
       settings,
       extensions,
-
       new ExtensionEnablementManager(
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'session-id',
       argv,
     );
     expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(
@@ -1283,7 +1252,6 @@ describe('mergeMcpServers', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(settings).toEqual(originalSettings);
@@ -1333,7 +1301,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(
@@ -1364,7 +1331,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(
@@ -1404,7 +1370,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(
@@ -1426,7 +1391,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual([]);
@@ -1445,7 +1409,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(defaultExcludes);
@@ -1463,7 +1426,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(
@@ -1494,7 +1456,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toEqual(
@@ -1526,7 +1487,6 @@ describe('mergeExcludeTools', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(settings).toEqual(originalSettings);
@@ -1558,7 +1518,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1588,7 +1547,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1618,7 +1576,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1648,7 +1605,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1678,7 +1634,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1701,7 +1656,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1736,7 +1690,7 @@ describe('Approval mode tool exclusion logic', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
 
@@ -1767,7 +1721,6 @@ describe('Approval mode tool exclusion logic', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -1797,7 +1750,7 @@ describe('Approval mode tool exclusion logic', () => {
           ExtensionStorage.getUserExtensionsDir(),
           invalidArgv.extensions,
         ),
-        'test-session',
+
         invalidArgv as CliArgs,
       ),
     ).rejects.toThrow(
@@ -1839,7 +1792,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual(baseSettings.mcpServers);
@@ -1860,7 +1812,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -1885,7 +1836,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -1911,7 +1861,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -1929,7 +1878,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({});
@@ -1949,7 +1897,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -1972,7 +1919,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -1997,7 +1943,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -2027,7 +1972,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -2059,7 +2003,6 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getMcpServers()).toEqual({
@@ -2094,7 +2037,6 @@ describe('loadCliConfig extensions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExtensionContextFilePaths()).toEqual([
@@ -2114,7 +2056,6 @@ describe('loadCliConfig extensions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExtensionContextFilePaths()).toEqual(['/path/to/ext1.md']);
@@ -2136,7 +2077,6 @@ describe('loadCliConfig model selection', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -2155,7 +2095,6 @@ describe('loadCliConfig model selection', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -2176,7 +2115,6 @@ describe('loadCliConfig model selection', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -2195,7 +2133,6 @@ describe('loadCliConfig model selection', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
 
@@ -2235,7 +2172,6 @@ describe('loadCliConfig folderTrust', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getFolderTrust()).toBe(false);
@@ -2258,7 +2194,6 @@ describe('loadCliConfig folderTrust', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getFolderTrust()).toBe(true);
@@ -2275,7 +2210,6 @@ describe('loadCliConfig folderTrust', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getFolderTrust()).toBe(false);
@@ -2325,7 +2259,6 @@ describe('loadCliConfig with includeDirectories', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     const expected = [
@@ -2377,7 +2310,6 @@ describe('loadCliConfig chatCompression', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getChatCompression()).toEqual({
@@ -2396,7 +2328,6 @@ describe('loadCliConfig chatCompression', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getChatCompression()).toBeUndefined();
@@ -2429,7 +2360,6 @@ describe('loadCliConfig useRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseRipgrep()).toBe(true);
@@ -2446,7 +2376,6 @@ describe('loadCliConfig useRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseRipgrep()).toBe(false);
@@ -2463,7 +2392,6 @@ describe('loadCliConfig useRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseRipgrep()).toBe(true);
@@ -2496,7 +2424,6 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseBuiltinRipgrep()).toBe(true);
@@ -2513,7 +2440,6 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseBuiltinRipgrep()).toBe(false);
@@ -2530,7 +2456,6 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getUseBuiltinRipgrep()).toBe(true);
@@ -2565,7 +2490,6 @@ describe('screenReader configuration', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getScreenReader()).toBe(true);
@@ -2584,7 +2508,6 @@ describe('screenReader configuration', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getScreenReader()).toBe(false);
@@ -2603,7 +2526,6 @@ describe('screenReader configuration', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getScreenReader()).toBe(true);
@@ -2620,7 +2542,6 @@ describe('screenReader configuration', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getScreenReader()).toBe(false);
@@ -2657,7 +2578,6 @@ describe('loadCliConfig tool exclusions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2676,7 +2596,6 @@ describe('loadCliConfig tool exclusions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2695,7 +2614,6 @@ describe('loadCliConfig tool exclusions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).toContain('run_shell_command');
@@ -2714,7 +2632,6 @@ describe('loadCliConfig tool exclusions', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2752,7 +2669,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(true);
@@ -2769,7 +2685,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(true);
@@ -2786,7 +2701,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(false);
@@ -2803,7 +2717,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(false);
@@ -2820,7 +2733,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(false);
@@ -2844,7 +2756,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(false);
@@ -2864,7 +2775,6 @@ describe('loadCliConfig interactive', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.isInteractive()).toBe(true);
@@ -2898,7 +2808,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -2914,7 +2823,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -2930,7 +2838,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -2946,7 +2853,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -2962,7 +2868,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -2978,7 +2883,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.AUTO_EDIT);
@@ -2994,7 +2898,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -3011,7 +2914,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -3028,7 +2930,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.AUTO_EDIT);
@@ -3046,7 +2947,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       ),
     ).rejects.toThrow(
@@ -3068,7 +2969,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3084,7 +2984,6 @@ describe('loadCliConfig approval mode', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -3109,7 +3008,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3125,7 +3024,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3141,7 +3040,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3157,7 +3056,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3173,7 +3072,7 @@ describe('loadCliConfig approval mode', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -3260,7 +3159,7 @@ describe('loadCliConfig fileFiltering', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       );
       expect(getter(config)).toBe(value);
@@ -3279,7 +3178,6 @@ describe('Output format', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getOutputFormat()).toBe(OutputFormat.TEXT);
@@ -3295,7 +3193,6 @@ describe('Output format', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
@@ -3311,7 +3208,6 @@ describe('Output format', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
@@ -3404,7 +3300,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -3422,7 +3317,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryTarget()).toBe('gcp');
@@ -3441,7 +3335,7 @@ describe('Telemetry configuration via environment variables', () => {
           ExtensionStorage.getUserExtensionsDir(),
           argv.extensions,
         ),
-        'test-session',
+
         argv,
       ),
     ).rejects.toThrow(
@@ -3465,7 +3359,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpEndpoint()).toBe('http://gemini.env.com');
@@ -3483,7 +3376,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -3501,7 +3393,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -3521,7 +3412,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryOutfile()).toBe('/gemini/env/telemetry.log');
@@ -3539,7 +3429,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryUseCollector()).toBe(true);
@@ -3557,7 +3446,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -3575,7 +3463,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryTarget()).toBe('local');
@@ -3592,7 +3479,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(true);
@@ -3609,7 +3495,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryEnabled()).toBe(false);
@@ -3626,7 +3511,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -3643,7 +3527,6 @@ describe('Telemetry configuration via environment variables', () => {
         ExtensionStorage.getUserExtensionsDir(),
         argv.extensions,
       ),
-      'test-session',
       argv,
     );
     expect(config.getTelemetryLogPromptsEnabled()).toBe(false);

packages/cli/src/config/config.ts

@@ -4,13 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type {
-  FileFilteringOptions,
-  MCPServerConfig,
-} from '@qwen-code/qwen-code-core';
-import { extensionsCommand } from '../commands/extensions.js';
 import {
   ApprovalMode,
+  AuthType,
   Config,
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
@@ -26,7 +22,12 @@ import {
   Storage,
   InputFormat,
   OutputFormat,
+  SessionService,
+  type ResumedSessionData,
+  type FileFilteringOptions,
+  type MCPServerConfig,
 } from '@qwen-code/qwen-code-core';
+import { extensionsCommand } from '../commands/extensions.js';
 import type { Settings } from './settings.js';
 import yargs, { type Argv } from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -129,6 +130,14 @@ export interface CliArgs {
   inputFormat?: string | undefined;
   outputFormat: string | undefined;
   includePartialMessages?: boolean;
+  /** Resume the most recent session for the current project */
+  continue: boolean | undefined;
+  /** Resume a specific session by its ID */
+  resume: string | undefined;
+  maxSessionTurns: number | undefined;
+  coreTools: string[] | undefined;
+  excludeTools: string[] | undefined;
+  authType: string | undefined;
 }
 
 function normalizeOutputFormat(
@@ -396,6 +405,47 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
             'Include partial assistant messages when using stream-json output.',
           default: false,
         })
+        .option('continue', {
+          type: 'boolean',
+          description:
+            'Resume the most recent session for the current project.',
+          default: false,
+        })
+        .option('resume', {
+          type: 'string',
+          description:
+            'Resume a specific session by its ID. Use without an ID to show session picker.',
+        })
+        .option('max-session-turns', {
+          type: 'number',
+          description: 'Maximum number of session turns',
+        })
+        .option('core-tools', {
+          type: 'array',
+          string: true,
+          description: 'Core tool paths',
+          coerce: (tools: string[]) =>
+            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
+        })
+        .option('exclude-tools', {
+          type: 'array',
+          string: true,
+          description: 'Tools to exclude',
+          coerce: (tools: string[]) =>
+            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
+        })
+        .option('allowed-tools', {
+          type: 'array',
+          string: true,
+          description: 'Tools to allow, will bypass confirmation',
+          coerce: (tools: string[]) =>
+            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
+        })
+        .option('auth-type', {
+          type: 'string',
+          choices: [AuthType.USE_OPENAI, AuthType.QWEN_OAUTH],
+          description: 'Authentication type',
+        })
         .deprecateOption(
           'show-memory-usage',
           'Use the "ui.showMemoryUsage" setting in settings.json instead. This flag will be removed in a future version.',
@@ -451,6 +501,9 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
           ) {
             return '--input-format stream-json requires --output-format stream-json';
           }
+          if (argv['continue'] && argv['resume']) {
+            return 'Cannot use both --continue and --resume together. Use --continue to resume the latest session, or --resume <sessionId> to resume a specific session.';
+          }
           return true;
         }),
     )
@@ -565,7 +618,6 @@ export async function loadCliConfig(
   settings: Settings,
   extensions: Extension[],
   extensionEnablementManager: ExtensionEnablementManager,
-  sessionId: string,
   argv: CliArgs,
   cwd: string = process.cwd(),
 ): Promise<Config> {
@@ -728,8 +780,14 @@ export async function loadCliConfig(
     interactive = false;
   }
   // In non-interactive mode, exclude tools that require a prompt.
+  // However, if stream-json input is used, control can be requested via JSON messages,
+  // so tools should not be excluded in that case.
   const extraExcludes: string[] = [];
-  if (!interactive && !argv.experimentalAcp) {
+  if (
+    !interactive &&
+    !argv.experimentalAcp &&
+    inputFormat !== InputFormat.STREAM_JSON
+  ) {
     switch (approvalMode) {
       case ApprovalMode.PLAN:
       case ApprovalMode.DEFAULT:
@@ -753,6 +811,7 @@ export async function loadCliConfig(
     settings,
     activeExtensions,
     extraExcludes.length > 0 ? extraExcludes : undefined,
+    argv.excludeTools,
   );
   const blockedMcpServers: Array<{ name: string; extensionName: string }> = [];
 
@@ -797,8 +856,33 @@ export async function loadCliConfig(
 
   const vlmSwitchMode =
     argv.vlmSwitchMode || settings.experimental?.vlmSwitchMode;
+
+  let sessionId: string | undefined;
+  let sessionData: ResumedSessionData | undefined;
+
+  if (argv.continue || argv.resume) {
+    const sessionService = new SessionService(cwd);
+    if (argv.continue) {
+      sessionData = await sessionService.loadLastSession();
+      if (sessionData) {
+        sessionId = sessionData.conversation.sessionId;
+      }
+    }
+
+    if (argv.resume) {
+      sessionId = argv.resume;
+      sessionData = await sessionService.loadSession(argv.resume);
+      if (!sessionData) {
+        const message = `No saved session found with ID ${argv.resume}. Run \`qwen --resume\` without an ID to choose from existing sessions.`;
+        console.log(message);
+        process.exit(1);
+      }
+    }
+  }
+
   return new Config({
     sessionId,
+    sessionData,
     embeddingModel: DEFAULT_QWEN_EMBEDDING_MODEL,
     sandbox: sandboxConfig,
     targetDir: cwd,
@@ -808,7 +892,7 @@ export async function loadCliConfig(
     debugMode,
     question,
     fullContext: argv.allFiles || false,
-    coreTools: settings.tools?.core || undefined,
+    coreTools: argv.coreTools || settings.tools?.core || undefined,
     allowedTools: argv.allowedTools || settings.tools?.allowed || undefined,
     excludeTools,
     toolDiscoveryCommand: settings.tools?.discoveryCommand,
@@ -841,13 +925,16 @@ export async function loadCliConfig(
     model: resolvedModel,
     extensionContextFilePaths,
     sessionTokenLimit: settings.model?.sessionTokenLimit ?? -1,
-    maxSessionTurns: settings.model?.maxSessionTurns ?? -1,
+    maxSessionTurns:
+      argv.maxSessionTurns ?? settings.model?.maxSessionTurns ?? -1,
     experimentalZedIntegration: argv.experimentalAcp || false,
     listExtensions: argv.listExtensions || false,
     extensions: allExtensions,
     blockedMcpServers,
     noBrowser: !!process.env['NO_BROWSER'],
-    authType: settings.security?.auth?.selectedType,
+    authType:
+      (argv.authType as AuthType | undefined) ||
+      settings.security?.auth?.selectedType,
     inputFormat,
     outputFormat,
     includePartialMessages,
@@ -955,8 +1042,10 @@ function mergeExcludeTools(
   settings: Settings,
   extensions: Extension[],
   extraExcludes?: string[] | undefined,
+  cliExcludeTools?: string[] | undefined,
 ): string[] {
   const allExcludeTools = new Set([
+    ...(cliExcludeTools || []),
     ...(settings.tools?.exclude || []),
     ...(extraExcludes || []),
   ]);

packages/cli/src/config/extension.ts

@@ -30,7 +30,6 @@ import { getErrorMessage } from '../utils/errors.js';
 import { recursivelyHydrateStrings } from './extensions/variables.js';
 import { isWorkspaceTrusted } from './trustedFolders.js';
 import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
-import { randomUUID } from 'node:crypto';
 import {
   cloneFromGit,
   downloadFromGitHubRelease,
@@ -134,7 +133,6 @@ function getTelemetryConfig(cwd: string) {
   const config = new Config({
     telemetry: settings.merged.telemetry,
     interactive: false,
-    sessionId: randomUUID(),
     targetDir: cwd,
     cwd,
     model: '',

packages/cli/src/gemini.test.tsx

@@ -479,6 +479,12 @@ describe('gemini.tsx main function kitty protocol', () => {
       inputFormat: undefined,
       outputFormat: undefined,
       includePartialMessages: undefined,
+      continue: undefined,
+      resume: undefined,
+      coreTools: undefined,
+      excludeTools: undefined,
+      authType: undefined,
+      maxSessionTurns: undefined,
     });
 
     await main();

packages/cli/src/gemini.tsx

@@ -12,7 +12,6 @@ import {
   logUserPrompt,
 } from '@qwen-code/qwen-code-core';
 import { render } from 'ink';
-import { randomUUID } from 'node:crypto';
 import dns from 'node:dns';
 import os from 'node:os';
 import { basename } from 'node:path';
@@ -59,6 +58,7 @@ import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
 import { getCliVersion } from './utils/version.js';
 import { computeWindowTitle } from './utils/windowTitle.js';
 import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
+import { showResumeSessionPicker } from './ui/components/ResumeSessionPicker.js';
 
 export function validateDnsResolutionOrder(
   order: string | undefined,
@@ -110,7 +110,7 @@ function getNodeMemoryArgs(isDebugMode: boolean): string[] {
 
 import { ExtensionEnablementManager } from './config/extensions/extensionEnablement.js';
 import { loadSandboxConfig } from './config/sandboxConfig.js';
-import { runZedIntegration } from './zed-integration/zedIntegration.js';
+import { runAcpAgent } from './acp-integration/acpAgent.js';
 
 export function setupUnhandledRejectionHandler() {
   let unhandledRejectionOccurred = false;
@@ -158,7 +158,7 @@ export async function startInteractiveUI(
             process.platform === 'win32' || nodeMajorVersion < 20
           }
         >
-          <SessionStatsProvider>
+          <SessionStatsProvider sessionId={config.getSessionId()}>
             <VimModeProvider settings={settings}>
               <AppContainer
                 config={config}
@@ -207,9 +207,8 @@ export async function main() {
   const settings = loadSettings();
   migrateDeprecatedSettings(settings);
   await cleanupCheckpoints();
-  const sessionId = randomUUID();
 
-  const argv = await parseArguments(settings.merged);
+  let argv = await parseArguments(settings.merged);
 
   // Check for invalid input combinations early to prevent crashes
   if (argv.promptInteractive && !process.stdin.isTTY) {
@@ -253,7 +252,6 @@ export async function main() {
         settings.merged,
         [],
         new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir()),
-        sessionId,
         argv,
       );
 
@@ -278,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();
       }
 
@@ -319,6 +320,18 @@ export async function main() {
     }
   }
 
+  // Handle --resume without a session ID by showing the session picker
+  if (argv.resume === '') {
+    const selectedSessionId = await showResumeSessionPicker();
+    if (!selectedSessionId) {
+      // User cancelled or no sessions available
+      process.exit(0);
+    }
+
+    // Update argv with the selected session ID
+    argv = { ...argv, resume: selectedSessionId };
+  }
+
   // We are now past the logic handling potentially launching a child process
   // to run Gemini CLI. It is now safe to perform expensive initialization that
   // may have side effects.
@@ -332,7 +345,6 @@ export async function main() {
       settings.merged,
       extensions,
       extensionEnablementManager,
-      sessionId,
       argv,
     );
 
@@ -374,7 +386,18 @@ export async function main() {
 
     setMaxSizedBoxDebugging(isDebugMode);
 
-    const initializationResult = await initializeApp(config, settings);
+    // Check input format early to determine initialization flow
+    const inputFormat =
+      typeof config.getInputFormat === 'function'
+        ? config.getInputFormat()
+        : InputFormat.TEXT;
+
+    // For stream-json mode, defer config.initialize() until after the initialize control request
+    // For other modes, initialize normally
+    let initializationResult: InitializationResult | undefined;
+    if (inputFormat !== InputFormat.STREAM_JSON) {
+      initializationResult = await initializeApp(config, settings);
+    }
 
     if (
       settings.merged.security?.auth?.selectedType ===
@@ -386,7 +409,7 @@ export async function main() {
     }
 
     if (config.getExperimentalZedIntegration()) {
-      return runZedIntegration(config, settings, extensions, argv);
+      return runAcpAgent(config, settings, extensions, argv);
     }
 
     let input = config.getQuestion();
@@ -408,19 +431,15 @@ export async function main() {
         settings,
         startupWarnings,
         process.cwd(),
-        initializationResult,
+        initializationResult!,
       );
       return;
     }
 
-    await config.initialize();
-
-    // Check input format BEFORE reading stdin
-    // In STREAM_JSON mode, stdin should be left for StreamJsonInputReader
-    const inputFormat =
-      typeof config.getInputFormat === 'function'
-        ? config.getInputFormat()
-        : InputFormat.TEXT;
+    // For non-stream-json mode, initialize config here
+    if (inputFormat !== InputFormat.STREAM_JSON) {
+      await config.initialize();
+    }
 
     // Only read stdin if NOT in stream-json mode
     // In stream-json mode, stdin is used for protocol messages (control requests, etc.)
@@ -433,7 +452,8 @@ export async function main() {
     }
 
     const nonInteractiveConfig = await validateNonInteractiveAuth(
-      settings.merged.security?.auth?.selectedType,
+      (argv.authType as AuthType) ||
+        settings.merged.security?.auth?.selectedType,
       settings.merged.security?.auth?.useExternal,
       config,
       settings,
@@ -469,7 +489,7 @@ export async function main() {
     });
 
     if (config.getDebugMode()) {
-      console.log('Session ID: %s', sessionId);
+      console.log('Session ID: %s', config.getSessionId());
     }
 
     await runNonInteractive(nonInteractiveConfig, settings, input, prompt_id);

packages/cli/src/i18n/locales/en.js

@@ -110,7 +110,6 @@ export default {
     'open full Qwen Code documentation in your browser',
   'Configuration not available.': 'Configuration not available.',
   'change the auth method': 'change the auth method',
-  'Show quit confirmation dialog': 'Show quit confirmation dialog',
   'Copy the last result or code snippet to clipboard':
     'Copy the last result or code snippet to clipboard',
 
@@ -690,18 +689,6 @@ export default {
   'A custom command wants to run the following shell commands:':
     'A custom command wants to run the following shell commands:',
 
-  // ============================================================================
-  // Dialogs - Quit Confirmation
-  // ============================================================================
-  'What would you like to do before exiting?':
-    'What would you like to do before exiting?',
-  'Quit immediately (/quit)': 'Quit immediately (/quit)',
-  'Generate summary and quit (/summary)':
-    'Generate summary and quit (/summary)',
-  'Save conversation and quit (/chat save)':
-    'Save conversation and quit (/chat save)',
-  'Cancel (stay in application)': 'Cancel (stay in application)',
-
   // ============================================================================
   // Dialogs - Pro Quota
   // ============================================================================

packages/cli/src/i18n/locales/zh.js

@@ -108,7 +108,6 @@ export default {
     '在浏览器中打开完整的 Qwen Code 文档',
   'Configuration not available.': '配置不可用',
   'change the auth method': '更改认证方法',
-  'Show quit confirmation dialog': '显示退出确认对话框',
   'Copy the last result or code snippet to clipboard':
     '将最后的结果或代码片段复制到剪贴板',
 
@@ -655,15 +654,6 @@ export default {
   'A custom command wants to run the following shell commands:':
     '自定义命令想要运行以下 shell 命令：',
 
-  // ============================================================================
-  // Dialogs - Quit Confirmation
-  // ============================================================================
-  'What would you like to do before exiting?': '退出前您想要做什么？',
-  'Quit immediately (/quit)': '立即退出 (/quit)',
-  'Generate summary and quit (/summary)': '生成摘要并退出 (/summary)',
-  'Save conversation and quit (/chat save)': '保存对话并退出 (/chat save)',
-  'Cancel (stay in application)': '取消（留在应用程序中）',
-
   // ============================================================================
   // Dialogs - Pro Quota
   // ============================================================================

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
  */
@@ -26,8 +29,8 @@
 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 { PermissionController } from './controllers/permissionController.js';
+import { SdkMcpController } from './controllers/sdkMcpController.js';
 // import { HookController } from './controllers/hookController.js';
 import type {
   CLIControlRequest,
@@ -64,8 +67,8 @@ export class ControlDispatcher implements IPendingRequestRegistry {
 
   // Make controllers publicly accessible
   readonly systemController: SystemController;
-  // readonly permissionController: PermissionController;
-  // readonly mcpController: MCPController;
+  readonly permissionController: PermissionController;
+  readonly sdkMcpController: SdkMcpController;
   // readonly hookController: HookController;
 
   // Central pending request registries
@@ -83,12 +86,16 @@ export class ControlDispatcher implements IPendingRequestRegistry {
       this,
       'SystemController',
     );
-    // this.permissionController = new PermissionController(
-    //   context,
-    //   this,
-    //   'PermissionController',
-    // );
-    // this.mcpController = new MCPController(context, this, 'MCPController');
+    this.permissionController = new PermissionController(
+      context,
+      this,
+      'PermissionController',
+    );
+    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.permissionController.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
    */
@@ -302,13 +350,12 @@ export class ControlDispatcher implements IPendingRequestRegistry {
       case 'supported_commands':
         return this.systemController;
 
-      // case 'can_use_tool':
-      // case 'set_permission_mode':
-      //   return this.permissionController;
+      case 'can_use_tool':
+      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/ControlService.ts

@@ -29,7 +29,7 @@
 import type { IControlContext } from './ControlContext.js';
 import type { ControlDispatcher } from './ControlDispatcher.js';
 import type {
-  // PermissionServiceAPI,
+  PermissionServiceAPI,
   SystemServiceAPI,
   // McpServiceAPI,
   // HookServiceAPI,
@@ -61,43 +61,31 @@ export class ControlService {
    * Handles tool execution permissions, approval checks, and callbacks.
    * Delegates to the shared PermissionController instance.
    */
-  // get permission(): PermissionServiceAPI {
-  //   const controller = this.dispatcher.permissionController;
-  //   return {
-  //     /**
-  //      * Check if a tool should be allowed based on current permission settings
-  //      *
-  //      * Evaluates permission mode and tool registry to determine if execution
-  //      * should proceed. Can optionally modify tool arguments based on confirmation details.
-  //      *
-  //      * @param toolRequest - Tool call request information
-  //      * @param confirmationDetails - Optional confirmation details for UI
-  //      * @returns Permission decision with optional updated arguments
-  //      */
-  //     shouldAllowTool: controller.shouldAllowTool.bind(controller),
-  //
-  //     /**
-  //      * Build UI suggestions for tool confirmation dialogs
-  //      *
-  //      * Creates actionable permission suggestions based on tool confirmation details.
-  //      *
-  //      * @param confirmationDetails - Tool confirmation details
-  //      * @returns Array of permission suggestions or null
-  //      */
-  //     buildPermissionSuggestions:
-  //       controller.buildPermissionSuggestions.bind(controller),
-  //
-  //     /**
-  //      * Get callback for monitoring tool call status updates
-  //      *
-  //      * Returns callback function for integration with CoreToolScheduler.
-  //      *
-  //      * @returns Callback function for tool call updates
-  //      */
-  //     getToolCallUpdateCallback:
-  //       controller.getToolCallUpdateCallback.bind(controller),
-  //   };
-  // }
+  get permission(): PermissionServiceAPI {
+    const controller = this.dispatcher.permissionController;
+    return {
+      /**
+       * Build UI suggestions for tool confirmation dialogs
+       *
+       * Creates actionable permission suggestions based on tool confirmation details.
+       *
+       * @param confirmationDetails - Tool confirmation details
+       * @returns Array of permission suggestions or null
+       */
+      buildPermissionSuggestions:
+        controller.buildPermissionSuggestions.bind(controller),
+
+      /**
+       * Get callback for monitoring tool call status updates
+       *
+       * Returns callback function for integration with CoreToolScheduler.
+       *
+       * @returns Callback function for tool call updates
+       */
+      getToolCallUpdateCallback:
+        controller.getToolCallUpdateCallback.bind(controller),
+    };
+  }
 
   /**
    * System Domain API

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);
       }
@@ -174,7 +217,5 @@ export abstract class BaseController {
   /**
    * Cleanup resources
    */
-  cleanup(): void {
-    // Subclasses can override to add cleanup logic
-  }
+  cleanup(): void {}
 }

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

@@ -15,8 +15,10 @@
  */
 
 import type {
-  ToolCallRequestInfo,
   WaitingToolCall,
+  ToolExecuteConfirmationDetails,
+  ToolMcpConfirmationDetails,
+  ApprovalMode,
 } from '@qwen-code/qwen-code-core';
 import {
   InputFormat,
@@ -42,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:
@@ -68,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 ||
@@ -190,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',
@@ -206,6 +226,7 @@ export class PermissionController extends BaseController {
     }
 
     this.context.permissionMode = mode;
+    this.context.config.setApprovalMode(mode as ApprovalMode);
 
     if (this.context.debugMode) {
       console.error(
@@ -334,47 +355,6 @@ export class PermissionController extends BaseController {
     }
   }
 
-  /**
-   * Check if a tool should be executed based on current permission settings
-   *
-   * This is a convenience method for direct tool execution checks without
-   * going through the control request flow.
-   */
-  async shouldAllowTool(
-    toolRequest: ToolCallRequestInfo,
-    confirmationDetails?: unknown,
-  ): Promise<{
-    allowed: boolean;
-    message?: string;
-    updatedArgs?: Record<string, unknown>;
-  }> {
-    // Check permission mode
-    const modeResult = this.checkPermissionMode();
-    if (!modeResult.allowed) {
-      return {
-        allowed: false,
-        message: modeResult.message,
-      };
-    }
-
-    // Check tool registry
-    const registryResult = this.checkToolRegistry(toolRequest.name);
-    if (!registryResult.allowed) {
-      return {
-        allowed: false,
-        message: registryResult.message,
-      };
-    }
-
-    // If we have confirmation details, we could potentially modify args
-    // This is a hook for future enhancement
-    if (confirmationDetails) {
-      // Future: handle argument modifications based on confirmation details
-    }
-
-    return { allowed: true };
-  }
-
   /**
    * Get callback for monitoring tool calls and handling outgoing permission requests
    * This is passed to executeToolCall to hook into CoreToolScheduler updates
@@ -411,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;
 
@@ -439,7 +427,8 @@ export class PermissionController extends BaseController {
           permission_suggestions: permissionSuggestions,
           blocked_path: null,
         } as CLIControlPermissionRequest,
-        30000,
+        undefined, // use default timeout
+        this.context.abortSignal,
       );
 
       if (response.subtype !== 'success') {
@@ -462,8 +451,15 @@ export class PermissionController extends BaseController {
           ToolConfirmationOutcome.ProceedOnce,
         );
       } else {
+        // Extract cancel message from response if available
+        const cancelMessage =
+          typeof payload['message'] === 'string'
+            ? payload['message']
+            : undefined;
+
         await toolCall.confirmationDetails.onConfirm(
           ToolConfirmationOutcome.Cancel,
+          cancelMessage ? { cancelMessage } : undefined,
         );
       }
     } catch (error) {
@@ -473,9 +469,23 @@ export class PermissionController extends BaseController {
           error,
         );
       }
-      await toolCall.confirmationDetails.onConfirm(
-        ToolConfirmationOutcome.Cancel,
-      );
+      // On error, use default cancel message
+      // Only pass payload for exec and mcp types that support it
+      const confirmationType = toolCall.confirmationDetails.type;
+      if (['edit', 'exec', 'mcp'].includes(confirmationType)) {
+        const execOrMcpDetails = toolCall.confirmationDetails as
+          | ToolExecuteConfirmationDetails
+          | ToolMcpConfirmationDetails;
+        await execOrMcpDetails.onConfirm(
+          ToolConfirmationOutcome.Cancel,
+          undefined,
+        );
+      } else {
+        // For other types, don't pass payload (backward compatible)
+        await toolCall.confirmationDetails.onConfirm(
+          ToolConfirmationOutcome.Cancel,
+        );
+      }
     } finally {
       this.pendingOutgoingRequests.delete(toolCall.request.callId);
     }

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,7 +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 {
   /**
@@ -26,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`);
@@ -49,15 +67,130 @@ 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>> {
-    // Register SDK MCP servers if provided
-    if (payload.sdkMcpServers && Array.isArray(payload.sdkMcpServers)) {
-      for (const serverName of payload.sdkMcpServers) {
-        this.context.sdkMcpServers.add(serverName);
+    if (signal.aborted) {
+      throw new Error('Request aborted');
+    }
+
+    this.context.config.setSdkMode(true);
+
+    // 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
+        );
+      }
+
+      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' &&
+      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;
+        }
+      }
+
+      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,
+            );
+          }
+        }
+      }
+    }
+
+    if (payload.agents && Array.isArray(payload.agents)) {
+      try {
+        this.context.config.setSessionSubagents(payload.agents);
+
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Added ${payload.agents.length} session subagents to config`,
+          );
+        }
+      } catch (error) {
+        if (this.context.debugMode) {
+          console.error(
+            '[SystemController] Failed to add session subagents:',
+            error,
+          );
+        }
       }
     }
 
@@ -86,36 +219,98 @@ export class SystemController extends BaseController {
   buildControlCapabilities(): Record<string, unknown> {
     const capabilities: Record<string, unknown> = {
       can_handle_can_use_tool: true,
-      can_handle_hook_callback: true,
+      can_handle_hook_callback: false,
       can_set_permission_mode:
         typeof this.context.config.setApprovalMode === 'function',
       can_set_model: typeof this.context.config.setModel === 'function',
+      // SDK MCP servers are supported - messages routed through control plane
+      can_handle_mcp_message: true,
     };
 
-    // Check if MCP message handling is available
-    try {
-      const mcpProvider = this.context.config as unknown as {
-        getMcpServers?: () => Record<string, unknown> | undefined;
-      };
-      if (typeof mcpProvider.getMcpServers === 'function') {
-        const servers = mcpProvider.getMcpServers();
-        capabilities['can_handle_mcp_message'] = Boolean(
-          servers && Object.keys(servers).length > 0,
-        );
-      } else {
-        capabilities['can_handle_mcp_message'] = false;
-      }
-    } catch (error) {
+    return capabilities;
+  }
+
+  private normalizeMcpServerConfig(
+    serverName: string,
+    config?: CLIMcpServerConfig,
+  ): MCPServerConfig | null {
+    if (!config || typeof config !== 'object') {
       if (this.context.debugMode) {
         console.error(
-          '[SystemController] Failed to determine MCP capability:',
-          error,
+          `[SystemController] Ignoring invalid MCP server config for '${serverName}'`,
         );
       }
-      capabilities['can_handle_mcp_message'] = false;
+      return null;
     }
 
-    return capabilities;
+    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,
+    };
   }
 
   /**
@@ -151,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
@@ -189,27 +389,63 @@ export class SystemController extends BaseController {
   /**
    * Handle supported_commands request
    *
-   * Returns list of supported control commands
-   *
-   * Note: This list should match the ControlRequestType enum in
-   * packages/sdk/typescript/src/types/controlRequests.ts
+   * Returns list of supported slash commands loaded dynamically
    */
-  private async handleSupportedCommands(): Promise<Record<string, unknown>> {
-    const commands = [
-      'initialize',
-      'interrupt',
-      'set_model',
-      'supported_commands',
-      'can_use_tool',
-      'set_permission_mode',
-      'mcp_message',
-      'mcp_server_status',
-      'hook_callback',
-    ];
+  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',
-      commands,
+      commands: slashCommands,
     };
   }
+
+  /**
+   * 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(signal: AbortSignal): Promise<string[]> {
+    if (signal.aborted) {
+      return [];
+    }
+
+    try {
+      const service = await CommandService.create(
+        [new BuiltinCommandLoader(this.context.config)],
+        signal,
+      );
+
+      if (signal.aborted) {
+        return [];
+      }
+
+      const names = new Set<string>();
+      const commands = service.getCommands();
+      for (const command of commands) {
+        names.add(command.name);
+      }
+      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:',
+          error,
+        );
+      }
+      return [];
+    }
+  }
 }

packages/cli/src/nonInteractive/control/types/serviceAPIs.ts

@@ -13,10 +13,7 @@
  */
 
 import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import type {
-  ToolCallRequestInfo,
-  MCPServerConfig,
-} from '@qwen-code/qwen-code-core';
+import type { MCPServerConfig } from '@qwen-code/qwen-code-core';
 import type { PermissionSuggestion } from '../../types.js';
 
 /**
@@ -26,25 +23,6 @@ import type { PermissionSuggestion } from '../../types.js';
  * permission suggestions, and tool call monitoring callbacks.
  */
 export interface PermissionServiceAPI {
-  /**
-   * Check if a tool should be allowed based on current permission settings
-   *
-   * Evaluates permission mode and tool registry to determine if execution
-   * should proceed. Can optionally modify tool arguments based on confirmation details.
-   *
-   * @param toolRequest - Tool call request information containing name, args, and call ID
-   * @param confirmationDetails - Optional confirmation details for UI-driven approvals
-   * @returns Promise resolving to permission decision with optional updated arguments
-   */
-  shouldAllowTool(
-    toolRequest: ToolCallRequestInfo,
-    confirmationDetails?: unknown,
-  ): Promise<{
-    allowed: boolean;
-    message?: string;
-    updatedArgs?: Record<string, unknown>;
-  }>;
-
   /**
    * Build UI suggestions for tool confirmation dialogs
    *

packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.ts

@@ -13,7 +13,11 @@ import type {
   ServerGeminiStreamEvent,
   TaskResultDisplay,
 } from '@qwen-code/qwen-code-core';
-import { GeminiEventType, ToolErrorType } from '@qwen-code/qwen-code-core';
+import {
+  GeminiEventType,
+  ToolErrorType,
+  parseAndFormatApiError,
+} from '@qwen-code/qwen-code-core';
 import type { Part, GenerateContentResponseUsageMetadata } from '@google/genai';
 import type {
   CLIAssistantMessage,
@@ -600,6 +604,18 @@ export abstract class BaseJsonOutputAdapter {
         }
         this.finalizePendingBlocks(state, null);
         break;
+      case GeminiEventType.Error: {
+        // Format the error message using parseAndFormatApiError for consistency
+        // with interactive mode error display
+        const errorText = parseAndFormatApiError(
+          event.value.error,
+          this.config.getContentGeneratorConfig()?.authType,
+          undefined,
+          this.config.getModel(),
+        );
+        this.appendText(state, errorText, null);
+        break;
+      }
       default:
         break;
     }
@@ -939,9 +955,25 @@ export abstract class BaseJsonOutputAdapter {
     this.emitMessageImpl(message);
   }
 
+  /**
+   * Checks if responseParts contain any functionResponse with an error.
+   * This handles cancelled responses and other error cases where the error
+   * is embedded in responseParts rather than the top-level error field.
+   * @param responseParts - Array of Part objects
+   * @returns Error message if found, undefined otherwise
+   */
+  private checkResponsePartsForError(
+    responseParts: Part[] | undefined,
+  ): string | undefined {
+    // Use the shared helper function defined at file level
+    return checkResponsePartsForError(responseParts);
+  }
+
   /**
    * Emits a tool result message.
    * Collects execution denied tool calls for inclusion in result messages.
+   * Handles both explicit errors (response.error) and errors embedded in
+   * responseParts (e.g., cancelled responses).
    * @param request - Tool call request info
    * @param response - Tool call response info
    * @param parentToolUseId - Parent tool use ID (null for main agent)
@@ -951,6 +983,14 @@ export abstract class BaseJsonOutputAdapter {
     response: ToolCallResponseInfo,
     parentToolUseId: string | null = null,
   ): void {
+    // Check for errors in responseParts (e.g., cancelled responses)
+    const responsePartsError = this.checkResponsePartsForError(
+      response.responseParts,
+    );
+
+    // Determine if this is an error response
+    const hasError = Boolean(response.error) || Boolean(responsePartsError);
+
     // Track permission denials (execution denied errors)
     if (
       response.error &&
@@ -967,7 +1007,7 @@ export abstract class BaseJsonOutputAdapter {
     const block: ToolResultBlock = {
       type: 'tool_result',
       tool_use_id: request.callId,
-      is_error: Boolean(response.error),
+      is_error: hasError,
     };
     const content = toolResultContent(response);
     if (content !== undefined) {
@@ -1173,11 +1213,41 @@ export function partsToString(parts: Part[]): string {
     .join('');
 }
 
+/**
+ * Checks if responseParts contain any functionResponse with an error.
+ * Helper function for extracting error messages from responseParts.
+ * @param responseParts - Array of Part objects
+ * @returns Error message if found, undefined otherwise
+ */
+function checkResponsePartsForError(
+  responseParts: Part[] | undefined,
+): string | undefined {
+  if (!responseParts || responseParts.length === 0) {
+    return undefined;
+  }
+
+  for (const part of responseParts) {
+    if (
+      'functionResponse' in part &&
+      part.functionResponse?.response &&
+      typeof part.functionResponse.response === 'object' &&
+      'error' in part.functionResponse.response &&
+      part.functionResponse.response['error']
+    ) {
+      const error = part.functionResponse.response['error'];
+      return typeof error === 'string' ? error : String(error);
+    }
+  }
+
+  return undefined;
+}
+
 /**
  * Extracts content from tool response.
  * Uses functionResponsePartsToString to properly handle functionResponse parts,
  * which correctly extracts output content from functionResponse objects rather
  * than simply concatenating text or JSON.stringify.
+ * Also handles errors embedded in responseParts (e.g., cancelled responses).
  *
  * @param response - Tool call response
  * @returns String content or undefined
@@ -1188,6 +1258,11 @@ export function toolResultContent(
   if (response.error) {
     return response.error.message;
   }
+  // Check for errors in responseParts (e.g., cancelled responses)
+  const responsePartsError = checkResponsePartsForError(response.responseParts);
+  if (responsePartsError) {
+    return responsePartsError;
+  }
   if (
     typeof response.resultDisplay === 'string' &&
     response.resultDisplay.trim().length > 0

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

@@ -69,6 +69,7 @@ function createConfig(overrides: ConfigOverrides = {}): Config {
     getDebugMode: () => false,
     getApprovalMode: () => 'auto',
     getOutputFormat: () => 'stream-json',
+    initialize: vi.fn(),
   };
   return { ...base, ...overrides } as unknown as Config;
 }
@@ -152,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>;
@@ -186,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/types.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import type { SubagentConfig } from '@qwen-code/qwen-code-core';
 
 /**
  * Annotation for attaching metadata to content blocks
@@ -137,9 +138,8 @@ export interface CLISystemMessage {
     status: string;
   }>;
   model?: string;
-  permissionMode?: string;
+  permission_mode?: string;
   slash_commands?: string[];
-  apiKeySource?: string;
   qwen_code_version?: string;
   output_style?: string;
   agents?: string[];
@@ -295,10 +295,69 @@ 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?: string[];
+  /**
+   * 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[];
 }
 
 export interface CLIControlSetPermissionModeRequest {

packages/cli/src/nonInteractiveCli.test.ts

@@ -245,6 +245,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Test input' }],
       expect.any(AbortSignal),
       'prompt-id-1',
+      { isContinuation: false },
     );
     expect(processStdoutSpy).toHaveBeenCalledWith('Hello');
     expect(processStdoutSpy).toHaveBeenCalledWith(' World');
@@ -293,11 +294,21 @@ describe('runNonInteractive', () => {
       expect.any(AbortSignal),
       undefined,
     );
+    // Verify first call has isContinuation: false
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(
+      1,
+      [{ text: 'Use a tool' }],
+      expect.any(AbortSignal),
+      'prompt-id-2',
+      { isContinuation: false },
+    );
+    // Verify second call (after tool execution) has isContinuation: true
     expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(
       2,
       [{ text: 'Tool response' }],
       expect.any(AbortSignal),
       'prompt-id-2',
+      { isContinuation: true },
     );
     expect(processStdoutSpy).toHaveBeenCalledWith('Final answer');
     expect(processStdoutSpy).toHaveBeenCalledWith('\n');
@@ -372,6 +383,7 @@ describe('runNonInteractive', () => {
       ],
       expect.any(AbortSignal),
       'prompt-id-3',
+      { isContinuation: true },
     );
     expect(processStdoutSpy).toHaveBeenCalledWith('Sorry, let me try again.');
   });
@@ -497,6 +509,7 @@ describe('runNonInteractive', () => {
       processedParts,
       expect.any(AbortSignal),
       'prompt-id-7',
+      { isContinuation: false },
     );
 
     // 6. Assert the final output is correct
@@ -528,6 +541,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Test input' }],
       expect.any(AbortSignal),
       'prompt-id-1',
+      { isContinuation: false },
     );
 
     // JSON adapter emits array of messages, last one is result with stats
@@ -680,6 +694,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Empty response test' }],
       expect.any(AbortSignal),
       'prompt-id-empty',
+      { isContinuation: false },
     );
 
     // JSON adapter emits array of messages, last one is result with stats
@@ -831,6 +846,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Prompt from command' }],
       expect.any(AbortSignal),
       'prompt-id-slash',
+      { isContinuation: false },
     );
 
     expect(processStdoutSpy).toHaveBeenCalledWith('Response from command');
@@ -887,6 +903,7 @@ describe('runNonInteractive', () => {
       [{ text: '/unknowncommand' }],
       expect.any(AbortSignal),
       'prompt-id-unknown',
+      { isContinuation: false },
     );
 
     expect(processStdoutSpy).toHaveBeenCalledWith('Response to unknown');
@@ -1217,6 +1234,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Message from stream-json input' }],
       expect.any(AbortSignal),
       'prompt-envelope',
+      { isContinuation: false },
     );
   });
 
@@ -1692,6 +1710,7 @@ describe('runNonInteractive', () => {
       [{ text: 'Simple string content' }],
       expect.any(AbortSignal),
       'prompt-string-content',
+      { isContinuation: false },
     );
 
     // UserMessage with array of text blocks
@@ -1724,6 +1743,7 @@ describe('runNonInteractive', () => {
       [{ text: 'First part' }, { text: 'Second part' }],
       expect.any(AbortSignal),
       'prompt-blocks-content',
+      { isContinuation: false },
     );
   });
 });

packages/cli/src/nonInteractiveCli.ts

@@ -15,7 +15,9 @@ import {
   FatalInputError,
   promptIdContext,
   OutputFormat,
+  InputFormat,
   uiTelemetryService,
+  parseAndFormatApiError,
 } from '@qwen-code/qwen-code-core';
 import type { Content, Part, PartListUnion } from '@google/genai';
 import type { CLIUserMessage, PermissionMode } from './nonInteractive/types.js';
@@ -170,6 +172,7 @@ export async function runNonInteractive(
         adapter.emitMessage(systemMessage);
       }
 
+      let isFirstTurn = true;
       while (true) {
         turnCount++;
         if (
@@ -185,7 +188,9 @@ export async function runNonInteractive(
           currentMessages[0]?.parts || [],
           abortController.signal,
           prompt_id,
+          { isContinuation: !isFirstTurn },
         );
+        isFirstTurn = false;
 
         // Start assistant message for this turn
         if (adapter) {
@@ -205,10 +210,21 @@ export async function runNonInteractive(
             }
           } else {
             // Text output mode - direct stdout
-            if (event.type === GeminiEventType.Content) {
+            if (event.type === GeminiEventType.Thought) {
+              process.stdout.write(event.value.description);
+            } else if (event.type === GeminiEventType.Content) {
               process.stdout.write(event.value);
             } else if (event.type === GeminiEventType.ToolCallRequest) {
               toolCallRequests.push(event.value);
+            } else if (event.type === GeminiEventType.Error) {
+              // Format and output the error message for text mode
+              const errorText = parseAndFormatApiError(
+                event.value.error,
+                config.getContentGeneratorConfig()?.authType,
+                undefined,
+                config.getModel(),
+              );
+              process.stderr.write(`${errorText}\n`);
             }
           }
         }
@@ -225,40 +241,14 @@ export async function runNonInteractive(
           for (const requestInfo of toolCallRequests) {
             const finalRequestInfo = requestInfo;
 
-            /*
-            if (options.controlService) {
-              const permissionResult =
-                await options.controlService.permission.shouldAllowTool(
-                  requestInfo,
-                );
-              if (!permissionResult.allowed) {
-                if (config.getDebugMode()) {
-                  console.error(
-                    `[runNonInteractive] Tool execution denied: ${requestInfo.name}`,
-                    permissionResult.message ?? '',
-                  );
-                }
-                if (adapter && permissionResult.message) {
-                  adapter.emitSystemMessage('tool_denied', {
-                    tool: requestInfo.name,
-                    message: permissionResult.message,
-                  });
-                }
-                continue;
-              }
-
-              if (permissionResult.updatedArgs) {
-                finalRequestInfo = {
-                  ...requestInfo,
-                  args: permissionResult.updatedArgs,
-                };
-              }
-            }
-
-            const toolCallUpdateCallback = options.controlService
-              ? options.controlService.permission.getToolCallUpdateCallback()
-              : undefined;
-            */
+            const inputFormat =
+              typeof config.getInputFormat === 'function'
+                ? config.getInputFormat()
+                : InputFormat.TEXT;
+            const toolCallUpdateCallback =
+              inputFormat === InputFormat.STREAM_JSON && options.controlService
+                ? options.controlService.permission.getToolCallUpdateCallback()
+                : undefined;
 
             // Only pass outputUpdateHandler for Task tool
             const isTaskTool = finalRequestInfo.name === 'task';
@@ -277,13 +267,13 @@ export async function runNonInteractive(
               isTaskTool && taskToolProgressHandler
                 ? {
                     outputUpdateHandler: taskToolProgressHandler,
-                    /*
-                    toolCallUpdateCallback
-                      ? { onToolCallsUpdate: toolCallUpdateCallback }
-                      : undefined,
-                    */
+                    onToolCallsUpdate: toolCallUpdateCallback,
                   }
-                : undefined,
+                : toolCallUpdateCallback
+                  ? {
+                      onToolCallsUpdate: toolCallUpdateCallback,
+                    }
+                  : undefined,
             );
 
             // Note: In JSON mode, subagent messages are automatically added to the main
@@ -303,9 +293,6 @@ export async function runNonInteractive(
                   ? toolResponse.resultDisplay
                   : undefined,
               );
-              // Note: We no longer emit a separate system message for tool errors
-              // in JSON/STREAM_JSON mode, as the error is already captured in the
-              // tool_result block with is_error=true.
             }
 
             if (adapter) {

packages/cli/src/services/BuiltinCommandLoader.test.ts

@@ -56,7 +56,6 @@ import { restoreCommand } from '../ui/commands/restoreCommand.js';
 
 vi.mock('../ui/commands/authCommand.js', () => ({ authCommand: {} }));
 vi.mock('../ui/commands/bugCommand.js', () => ({ bugCommand: {} }));
-vi.mock('../ui/commands/chatCommand.js', () => ({ chatCommand: {} }));
 vi.mock('../ui/commands/clearCommand.js', () => ({ clearCommand: {} }));
 vi.mock('../ui/commands/compressCommand.js', () => ({ compressCommand: {} }));
 vi.mock('../ui/commands/corgiCommand.js', () => ({ corgiCommand: {} }));
@@ -72,7 +71,6 @@ vi.mock('../ui/commands/modelCommand.js', () => ({
 }));
 vi.mock('../ui/commands/quitCommand.js', () => ({
   quitCommand: {},
-  quitConfirmCommand: {},
 }));
 vi.mock('../ui/commands/statsCommand.js', () => ({ statsCommand: {} }));
 vi.mock('../ui/commands/themeCommand.js', () => ({ themeCommand: {} }));

packages/cli/src/services/BuiltinCommandLoader.ts

@@ -12,7 +12,6 @@ import { agentsCommand } from '../ui/commands/agentsCommand.js';
 import { approvalModeCommand } from '../ui/commands/approvalModeCommand.js';
 import { authCommand } from '../ui/commands/authCommand.js';
 import { bugCommand } from '../ui/commands/bugCommand.js';
-import { chatCommand } from '../ui/commands/chatCommand.js';
 import { clearCommand } from '../ui/commands/clearCommand.js';
 import { compressCommand } from '../ui/commands/compressCommand.js';
 import { copyCommand } from '../ui/commands/copyCommand.js';
@@ -29,7 +28,7 @@ import { mcpCommand } from '../ui/commands/mcpCommand.js';
 import { memoryCommand } from '../ui/commands/memoryCommand.js';
 import { modelCommand } from '../ui/commands/modelCommand.js';
 import { permissionsCommand } from '../ui/commands/permissionsCommand.js';
-import { quitCommand, quitConfirmCommand } from '../ui/commands/quitCommand.js';
+import { quitCommand } from '../ui/commands/quitCommand.js';
 import { restoreCommand } from '../ui/commands/restoreCommand.js';
 import { settingsCommand } from '../ui/commands/settingsCommand.js';
 import { statsCommand } from '../ui/commands/statsCommand.js';
@@ -61,7 +60,6 @@ export class BuiltinCommandLoader implements ICommandLoader {
       approvalModeCommand,
       authCommand,
       bugCommand,
-      chatCommand,
       clearCommand,
       compressCommand,
       copyCommand,
@@ -79,7 +77,6 @@ export class BuiltinCommandLoader implements ICommandLoader {
       modelCommand,
       ...(this.config?.getFolderTrust() ? [permissionsCommand] : []),
       quitCommand,
-      quitConfirmCommand,
       restoreCommand(this.config),
       statsCommand,
       summaryCommand,

packages/cli/src/test-utils/mockCommandContext.ts

@@ -9,6 +9,7 @@ import type { CommandContext } from '../ui/commands/types.js';
 import type { LoadedSettings } from '../config/settings.js';
 import type { GitService } from '@qwen-code/qwen-code-core';
 import type { SessionStatsState } from '../ui/contexts/SessionContext.js';
+import { ToolCallDecision } from '../ui/contexts/SessionContext.js';
 
 // A utility type to make all properties of an object, and its nested objects, partial.
 type DeepPartial<T> = T extends object
@@ -63,7 +64,9 @@ export const createMockCommandContext = (
     } as any,
     session: {
       sessionShellAllowlist: new Set<string>(),
+      startNewSession: vi.fn(),
       stats: {
+        sessionId: '',
         sessionStartTime: new Date(),
         lastPromptTokenCount: 0,
         metrics: {
@@ -73,9 +76,15 @@ export const createMockCommandContext = (
             totalSuccess: 0,
             totalFail: 0,
             totalDurationMs: 0,
-            totalDecisions: { accept: 0, reject: 0, modify: 0 },
+            totalDecisions: {
+              [ToolCallDecision.ACCEPT]: 0,
+              [ToolCallDecision.REJECT]: 0,
+              [ToolCallDecision.MODIFY]: 0,
+              [ToolCallDecision.AUTO_ACCEPT]: 0,
+            },
             byName: {},
           },
+          files: { totalLinesAdded: 0, totalLinesRemoved: 0 },
         },
         promptCount: 0,
       } as SessionStatsState,

packages/cli/src/ui/AppContainer.tsx

@@ -40,6 +40,7 @@ import {
   getAllGeminiMdFilenames,
   ShellExecutionService,
 } from '@qwen-code/qwen-code-core';
+import { buildResumedHistoryItems } from './utils/resumeHistoryUtils.js';
 import { validateAuthMethod } from '../config/auth.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
 import process from 'node:process';
@@ -88,7 +89,6 @@ import { useSessionStats } from './contexts/SessionContext.js';
 import { useGitBranchName } from './hooks/useGitBranchName.js';
 import { useExtensionUpdates } from './hooks/useExtensionUpdates.js';
 import { ShellFocusContext } from './contexts/ShellFocusContext.js';
-import { useQuitConfirmation } from './hooks/useQuitConfirmation.js';
 import { t } from '../i18n/index.js';
 import { useWelcomeBack } from './hooks/useWelcomeBack.js';
 import { useDialogClose } from './hooks/useDialogClose.js';
@@ -196,7 +196,6 @@ export const AppContainer = (props: AppContainerProps) => {
 
   const [isConfigInitialized, setConfigInitialized] = useState(false);
 
-  const logger = useLogger(config.storage);
   const [userMessages, setUserMessages] = useState<string[]>([]);
 
   // Terminal and layout hooks
@@ -206,6 +205,7 @@ export const AppContainer = (props: AppContainerProps) => {
 
   // Additional hooks moved from App.tsx
   const { stats: sessionStats } = useSessionStats();
+  const logger = useLogger(config.storage, sessionStats.sessionId);
   const branchName = useGitBranchName(config.getTargetDir());
 
   // Layout measurements
@@ -216,17 +216,28 @@ export const AppContainer = (props: AppContainerProps) => {
   const lastTitleRef = useRef<string | null>(null);
   const staticExtraHeight = 3;
 
+  // Initialize config (runs once on mount)
   useEffect(() => {
     (async () => {
       // Note: the program will not work if this fails so let errors be
       // handled by the global catch.
       await config.initialize();
       setConfigInitialized(true);
+
+      const resumedSessionData = config.getResumedSessionData();
+      if (resumedSessionData) {
+        const historyItems = buildResumedHistoryItems(
+          resumedSessionData,
+          config,
+        );
+        historyManager.loadHistory(historyItems);
+      }
     })();
     registerCleanup(async () => {
       const ideClient = await IdeClient.getInstance();
       await ideClient.disconnect();
     });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [config]);
 
   useEffect(
@@ -434,8 +445,6 @@ export const AppContainer = (props: AppContainerProps) => {
 
   const { toggleVimEnabled } = useVimMode();
 
-  const { showQuitConfirmation } = useQuitConfirmation();
-
   const {
     isSubagentCreateDialogOpen,
     openSubagentCreateDialog,
@@ -481,7 +490,6 @@ export const AppContainer = (props: AppContainerProps) => {
       addConfirmUpdateExtensionRequest,
       openSubagentCreateDialog,
       openAgentsManagerDialog,
-      _showQuitConfirmation: showQuitConfirmation,
     }),
     [
       openAuthDialog,
@@ -495,7 +503,6 @@ export const AppContainer = (props: AppContainerProps) => {
       openPermissionsDialog,
       openApprovalModeDialog,
       addConfirmUpdateExtensionRequest,
-      showQuitConfirmation,
       openSubagentCreateDialog,
       openAgentsManagerDialog,
     ],
@@ -508,7 +515,6 @@ export const AppContainer = (props: AppContainerProps) => {
     commandContext,
     shellConfirmationRequest,
     confirmationRequest,
-    quitConfirmationRequest,
   } = useSlashCommandProcessor(
     config,
     settings,
@@ -522,6 +528,7 @@ export const AppContainer = (props: AppContainerProps) => {
     slashCommandActions,
     extensionsUpdateStateInternal,
     isConfigInitialized,
+    logger,
   );
 
   // Vision switch handlers
@@ -956,7 +963,6 @@ export const AppContainer = (props: AppContainerProps) => {
     isFolderTrustDialogOpen,
     showWelcomeBackDialog,
     handleWelcomeBackClose,
-    quitConfirmationRequest,
   });
 
   const handleExit = useCallback(
@@ -970,25 +976,18 @@ export const AppContainer = (props: AppContainerProps) => {
         if (timerRef.current) {
           clearTimeout(timerRef.current);
         }
-        // Exit directly without showing confirmation dialog
+        // Exit directly
         handleSlashCommand('/quit');
         return;
       }
 
       // First press: Prioritize cleanup tasks
 
-      // Special case: If quit-confirm dialog is open, Ctrl+C means "quit immediately"
-      if (quitConfirmationRequest) {
-        handleSlashCommand('/quit');
-        return;
-      }
-
       // 1. Close other dialogs (highest priority)
       /**
        * For AuthDialog it is required to complete the authentication process,
        * otherwise user cannot proceed to the next step.
-       * So a quit on AuthDialog should go with normal two press quit
-       * and without quit-confirm dialog.
+       * So a quit on AuthDialog should go with normal two press quit.
        */
       if (isAuthDialogOpen) {
         setPressedOnce(true);
@@ -1009,14 +1008,17 @@ export const AppContainer = (props: AppContainerProps) => {
         return; // Request cancelled, end processing
       }
 
-      // 3. Clear input buffer (if has content)
+      // 4. Clear input buffer (if has content)
       if (buffer.text.length > 0) {
         buffer.setText('');
         return; // Input cleared, end processing
       }
 
-      // All cleanup tasks completed, show quit confirmation dialog
-      handleSlashCommand('/quit-confirm');
+      // All cleanup tasks completed, set flag for double-press to quit
+      setPressedOnce(true);
+      timerRef.current = setTimeout(() => {
+        setPressedOnce(false);
+      }, CTRL_EXIT_PROMPT_DURATION_MS);
     },
     [
       isAuthDialogOpen,
@@ -1024,7 +1026,6 @@ export const AppContainer = (props: AppContainerProps) => {
       closeAnyOpenDialog,
       streamingState,
       cancelOngoingRequest,
-      quitConfirmationRequest,
       buffer,
     ],
   );
@@ -1041,8 +1042,8 @@ export const AppContainer = (props: AppContainerProps) => {
           return;
         }
 
-        // On first press: set flag, start timer, and call handleExit for cleanup/quit-confirm
-        // On second press (within 500ms): handleExit sees flag and does fast quit
+        // On first press: set flag, start timer, and call handleExit for cleanup
+        // On second press (within timeout): handleExit sees flag and does fast quit
         if (!ctrlCPressedOnce) {
           setCtrlCPressedOnce(true);
           ctrlCTimerRef.current = setTimeout(() => {
@@ -1183,7 +1184,6 @@ export const AppContainer = (props: AppContainerProps) => {
     !!confirmationRequest ||
     confirmUpdateExtensionRequests.length > 0 ||
     !!loopDetectionConfirmationRequest ||
-    !!quitConfirmationRequest ||
     isThemeDialogOpen ||
     isSettingsDialogOpen ||
     isModelDialogOpen ||
@@ -1232,7 +1232,6 @@ export const AppContainer = (props: AppContainerProps) => {
       confirmationRequest,
       confirmUpdateExtensionRequests,
       loopDetectionConfirmationRequest,
-      quitConfirmationRequest,
       geminiMdFileCount,
       streamingState,
       initError,
@@ -1324,7 +1323,6 @@ export const AppContainer = (props: AppContainerProps) => {
       confirmationRequest,
       confirmUpdateExtensionRequests,
       loopDetectionConfirmationRequest,
-      quitConfirmationRequest,
       geminiMdFileCount,
       streamingState,
       initError,

packages/cli/src/ui/commands/chatCommand.test.ts

@@ -1,701 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Mocked } from 'vitest';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import type {
-  MessageActionReturn,
-  SlashCommand,
-  CommandContext,
-} from './types.js';
-import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
-import type { Content } from '@google/genai';
-import type { GeminiClient } from '@qwen-code/qwen-code-core';
-
-import * as fsPromises from 'node:fs/promises';
-import { chatCommand, serializeHistoryToMarkdown } from './chatCommand.js';
-import type { Stats } from 'node:fs';
-import type { HistoryItemWithoutId } from '../types.js';
-import path from 'node:path';
-
-vi.mock('fs/promises', () => ({
-  stat: vi.fn(),
-  readdir: vi.fn().mockResolvedValue(['file1.txt', 'file2.txt'] as string[]),
-  writeFile: vi.fn(),
-}));
-
-describe('chatCommand', () => {
-  const mockFs = fsPromises as Mocked<typeof fsPromises>;
-
-  let mockContext: CommandContext;
-  let mockGetChat: ReturnType<typeof vi.fn>;
-  let mockSaveCheckpoint: ReturnType<typeof vi.fn>;
-  let mockLoadCheckpoint: ReturnType<typeof vi.fn>;
-  let mockDeleteCheckpoint: ReturnType<typeof vi.fn>;
-  let mockGetHistory: ReturnType<typeof vi.fn>;
-
-  const getSubCommand = (
-    name: 'list' | 'save' | 'resume' | 'delete' | 'share',
-  ): SlashCommand => {
-    const subCommand = chatCommand.subCommands?.find(
-      (cmd) => cmd.name === name,
-    );
-    if (!subCommand) {
-      throw new Error(`/chat ${name} command not found.`);
-    }
-    return subCommand;
-  };
-
-  beforeEach(() => {
-    mockGetHistory = vi.fn().mockReturnValue([]);
-    mockGetChat = vi.fn().mockResolvedValue({
-      getHistory: mockGetHistory,
-    });
-    mockSaveCheckpoint = vi.fn().mockResolvedValue(undefined);
-    mockLoadCheckpoint = vi.fn().mockResolvedValue([]);
-    mockDeleteCheckpoint = vi.fn().mockResolvedValue(true);
-
-    mockContext = createMockCommandContext({
-      services: {
-        config: {
-          getProjectRoot: () => '/project/root',
-          getGeminiClient: () =>
-            ({
-              getChat: mockGetChat,
-            }) as unknown as GeminiClient,
-          storage: {
-            getProjectTempDir: () => '/project/root/.gemini/tmp/mockhash',
-          },
-        },
-        logger: {
-          saveCheckpoint: mockSaveCheckpoint,
-          loadCheckpoint: mockLoadCheckpoint,
-          deleteCheckpoint: mockDeleteCheckpoint,
-          initialize: vi.fn().mockResolvedValue(undefined),
-        },
-      },
-    });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should have the correct main command definition', () => {
-    expect(chatCommand.name).toBe('chat');
-    expect(chatCommand.description).toBe('Manage conversation history.');
-    expect(chatCommand.subCommands).toHaveLength(5);
-  });
-
-  describe('list subcommand', () => {
-    let listCommand: SlashCommand;
-
-    beforeEach(() => {
-      listCommand = getSubCommand('list');
-    });
-
-    it('should inform when no checkpoints are found', async () => {
-      mockFs.readdir.mockImplementation(
-        (async (_: string): Promise<string[]> =>
-          [] as string[]) as unknown as typeof fsPromises.readdir,
-      );
-      const result = await listCommand?.action?.(mockContext, '');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'No saved conversation checkpoints found.',
-      });
-    });
-
-    it('should list found checkpoints', async () => {
-      const fakeFiles = ['checkpoint-test1.json', 'checkpoint-test2.json'];
-      const date = new Date();
-
-      mockFs.readdir.mockImplementation(
-        (async (_: string): Promise<string[]> =>
-          fakeFiles as string[]) as unknown as typeof fsPromises.readdir,
-      );
-      mockFs.stat.mockImplementation((async (path: string): Promise<Stats> => {
-        if (path.endsWith('test1.json')) {
-          return { mtime: date } as Stats;
-        }
-        return { mtime: new Date(date.getTime() + 1000) } as Stats;
-      }) as unknown as typeof fsPromises.stat);
-
-      const result = (await listCommand?.action?.(
-        mockContext,
-        '',
-      )) as MessageActionReturn;
-
-      const content = result?.content ?? '';
-      expect(result?.type).toBe('message');
-      expect(content).toContain('List of saved conversations:');
-      const isoDate = date
-        .toISOString()
-        .match(/(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
-      const formattedDate = isoDate ? `${isoDate[1]} ${isoDate[2]}` : '';
-      expect(content).toContain(formattedDate);
-      const index1 = content.indexOf('- test1');
-      const index2 = content.indexOf('- test2');
-      expect(index1).toBeGreaterThanOrEqual(0);
-      expect(index2).toBeGreaterThan(index1);
-    });
-
-    it('should handle invalid date formats gracefully', async () => {
-      const fakeFiles = ['checkpoint-baddate.json'];
-      const badDate = {
-        toISOString: () => 'an-invalid-date-string',
-      } as Date;
-
-      mockFs.readdir.mockResolvedValue(fakeFiles);
-      mockFs.stat.mockResolvedValue({ mtime: badDate } as Stats);
-
-      const result = (await listCommand?.action?.(
-        mockContext,
-        '',
-      )) as MessageActionReturn;
-
-      const content = result?.content ?? '';
-      expect(content).toContain('(saved on Invalid Date)');
-    });
-  });
-  describe('save subcommand', () => {
-    let saveCommand: SlashCommand;
-    const tag = 'my-tag';
-    let mockCheckpointExists: ReturnType<typeof vi.fn>;
-
-    beforeEach(() => {
-      saveCommand = getSubCommand('save');
-      mockCheckpointExists = vi.fn().mockResolvedValue(false);
-      mockContext.services.logger.checkpointExists = mockCheckpointExists;
-    });
-
-    it('should return an error if tag is missing', async () => {
-      const result = await saveCommand?.action?.(mockContext, '  ');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Missing tag. Usage: /chat save <tag>',
-      });
-    });
-
-    it('should inform if conversation history is empty or only contains system context', async () => {
-      mockGetHistory.mockReturnValue([]);
-      let result = await saveCommand?.action?.(mockContext, tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'No conversation found to save.',
-      });
-
-      mockGetHistory.mockReturnValue([
-        { role: 'user', parts: [{ text: 'context for our chat' }] },
-        { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-      ]);
-      result = await saveCommand?.action?.(mockContext, tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'No conversation found to save.',
-      });
-
-      mockGetHistory.mockReturnValue([
-        { role: 'user', parts: [{ text: 'context for our chat' }] },
-        { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-        { role: 'user', parts: [{ text: 'Hello, how are you?' }] },
-      ]);
-      result = await saveCommand?.action?.(mockContext, tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation checkpoint saved with tag: ${tag}.`,
-      });
-    });
-
-    it('should return confirm_action if checkpoint already exists', async () => {
-      mockCheckpointExists.mockResolvedValue(true);
-      mockContext.invocation = {
-        raw: `/chat save ${tag}`,
-        name: 'save',
-        args: tag,
-      };
-
-      const result = await saveCommand?.action?.(mockContext, tag);
-
-      expect(mockCheckpointExists).toHaveBeenCalledWith(tag);
-      expect(mockSaveCheckpoint).not.toHaveBeenCalled();
-      expect(result).toMatchObject({
-        type: 'confirm_action',
-        originalInvocation: { raw: `/chat save ${tag}` },
-      });
-      // Check that prompt is a React element
-      expect(result).toHaveProperty('prompt');
-    });
-
-    it('should save the conversation if overwrite is confirmed', async () => {
-      const history: Content[] = [
-        { role: 'user', parts: [{ text: 'context for our chat' }] },
-        { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-        { role: 'user', parts: [{ text: 'hello' }] },
-        { role: 'model', parts: [{ text: 'Hi there!' }] },
-      ];
-      mockGetHistory.mockReturnValue(history);
-      mockContext.overwriteConfirmed = true;
-
-      const result = await saveCommand?.action?.(mockContext, tag);
-
-      expect(mockCheckpointExists).not.toHaveBeenCalled(); // Should skip existence check
-      expect(mockSaveCheckpoint).toHaveBeenCalledWith(history, tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation checkpoint saved with tag: ${tag}.`,
-      });
-    });
-  });
-
-  describe('resume subcommand', () => {
-    const goodTag = 'good-tag';
-    const badTag = 'bad-tag';
-
-    let resumeCommand: SlashCommand;
-    beforeEach(() => {
-      resumeCommand = getSubCommand('resume');
-    });
-
-    it('should return an error if tag is missing', async () => {
-      const result = await resumeCommand?.action?.(mockContext, '');
-
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Missing tag. Usage: /chat resume <tag>',
-      });
-    });
-
-    it('should inform if checkpoint is not found', async () => {
-      mockLoadCheckpoint.mockResolvedValue([]);
-
-      const result = await resumeCommand?.action?.(mockContext, badTag);
-
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `No saved checkpoint found with tag: ${badTag}.`,
-      });
-    });
-
-    it('should resume a conversation', async () => {
-      const conversation: Content[] = [
-        { role: 'user', parts: [{ text: 'hello gemini' }] },
-        { role: 'model', parts: [{ text: 'hello world' }] },
-      ];
-      mockLoadCheckpoint.mockResolvedValue(conversation);
-
-      const result = await resumeCommand?.action?.(mockContext, goodTag);
-
-      expect(result).toEqual({
-        type: 'load_history',
-        history: [
-          { type: 'user', text: 'hello gemini' },
-          { type: 'gemini', text: 'hello world' },
-        ] as HistoryItemWithoutId[],
-        clientHistory: conversation,
-      });
-    });
-
-    describe('completion', () => {
-      it('should provide completion suggestions', async () => {
-        const fakeFiles = ['checkpoint-alpha.json', 'checkpoint-beta.json'];
-        mockFs.readdir.mockImplementation(
-          (async (_: string): Promise<string[]> =>
-            fakeFiles as string[]) as unknown as typeof fsPromises.readdir,
-        );
-
-        mockFs.stat.mockImplementation(
-          (async (_: string): Promise<Stats> =>
-            ({
-              mtime: new Date(),
-            }) as Stats) as unknown as typeof fsPromises.stat,
-        );
-
-        const result = await resumeCommand?.completion?.(mockContext, 'a');
-
-        expect(result).toEqual(['alpha']);
-      });
-
-      it('should suggest filenames sorted by modified time (newest first)', async () => {
-        const fakeFiles = ['checkpoint-test1.json', 'checkpoint-test2.json'];
-        const date = new Date();
-        mockFs.readdir.mockImplementation(
-          (async (_: string): Promise<string[]> =>
-            fakeFiles as string[]) as unknown as typeof fsPromises.readdir,
-        );
-        mockFs.stat.mockImplementation((async (
-          path: string,
-        ): Promise<Stats> => {
-          if (path.endsWith('test1.json')) {
-            return { mtime: date } as Stats;
-          }
-          return { mtime: new Date(date.getTime() + 1000) } as Stats;
-        }) as unknown as typeof fsPromises.stat);
-
-        const result = await resumeCommand?.completion?.(mockContext, '');
-        // Sort items by last modified time (newest first)
-        expect(result).toEqual(['test2', 'test1']);
-      });
-    });
-  });
-
-  describe('delete subcommand', () => {
-    let deleteCommand: SlashCommand;
-    const tag = 'my-tag';
-    beforeEach(() => {
-      deleteCommand = getSubCommand('delete');
-    });
-
-    it('should return an error if tag is missing', async () => {
-      const result = await deleteCommand?.action?.(mockContext, '  ');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Missing tag. Usage: /chat delete <tag>',
-      });
-    });
-
-    it('should return an error if checkpoint is not found', async () => {
-      mockDeleteCheckpoint.mockResolvedValue(false);
-      const result = await deleteCommand?.action?.(mockContext, tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: `Error: No checkpoint found with tag '${tag}'.`,
-      });
-    });
-
-    it('should delete the conversation', async () => {
-      const result = await deleteCommand?.action?.(mockContext, tag);
-
-      expect(mockDeleteCheckpoint).toHaveBeenCalledWith(tag);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation checkpoint '${tag}' has been deleted.`,
-      });
-    });
-
-    describe('completion', () => {
-      it('should provide completion suggestions', async () => {
-        const fakeFiles = ['checkpoint-alpha.json', 'checkpoint-beta.json'];
-        mockFs.readdir.mockImplementation(
-          (async (_: string): Promise<string[]> =>
-            fakeFiles as string[]) as unknown as typeof fsPromises.readdir,
-        );
-
-        mockFs.stat.mockImplementation(
-          (async (_: string): Promise<Stats> =>
-            ({
-              mtime: new Date(),
-            }) as Stats) as unknown as typeof fsPromises.stat,
-        );
-
-        const result = await deleteCommand?.completion?.(mockContext, 'a');
-
-        expect(result).toEqual(['alpha']);
-      });
-    });
-  });
-
-  describe('share subcommand', () => {
-    let shareCommand: SlashCommand;
-    const mockHistory = [
-      { role: 'user', parts: [{ text: 'context' }] },
-      { role: 'model', parts: [{ text: 'context response' }] },
-      { role: 'user', parts: [{ text: 'Hello' }] },
-      { role: 'model', parts: [{ text: 'Hi there!' }] },
-    ];
-
-    beforeEach(() => {
-      shareCommand = getSubCommand('share');
-      vi.spyOn(process, 'cwd').mockReturnValue(
-        path.resolve('/usr/local/google/home/myuser/gemini-cli'),
-      );
-      vi.spyOn(Date, 'now').mockReturnValue(1234567890);
-      mockGetHistory.mockReturnValue(mockHistory);
-      mockFs.writeFile.mockClear();
-    });
-
-    it('should default to a json file if no path is provided', async () => {
-      const result = await shareCommand?.action?.(mockContext, '');
-      const expectedPath = path.join(
-        process.cwd(),
-        'gemini-conversation-1234567890.json',
-      );
-      const [actualPath, actualContent] = mockFs.writeFile.mock.calls[0];
-      expect(actualPath).toEqual(expectedPath);
-      expect(actualContent).toEqual(JSON.stringify(mockHistory, null, 2));
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation shared to ${expectedPath}`,
-      });
-    });
-
-    it('should share the conversation to a JSON file', async () => {
-      const filePath = 'my-chat.json';
-      const result = await shareCommand?.action?.(mockContext, filePath);
-      const expectedPath = path.join(process.cwd(), 'my-chat.json');
-      const [actualPath, actualContent] = mockFs.writeFile.mock.calls[0];
-      expect(actualPath).toEqual(expectedPath);
-      expect(actualContent).toEqual(JSON.stringify(mockHistory, null, 2));
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation shared to ${expectedPath}`,
-      });
-    });
-
-    it('should share the conversation to a Markdown file', async () => {
-      const filePath = 'my-chat.md';
-      const result = await shareCommand?.action?.(mockContext, filePath);
-      const expectedPath = path.join(process.cwd(), 'my-chat.md');
-      const [actualPath, actualContent] = mockFs.writeFile.mock.calls[0];
-      expect(actualPath).toEqual(expectedPath);
-      const expectedContent = `🧑‍💻 ## USER
-
-context
-
----
-
-✨ ## MODEL
-
-context response
-
----
-
-🧑‍💻 ## USER
-
-Hello
-
----
-
-✨ ## MODEL
-
-Hi there!`;
-      expect(actualContent).toEqual(expectedContent);
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: `Conversation shared to ${expectedPath}`,
-      });
-    });
-
-    it('should return an error for unsupported file extensions', async () => {
-      const filePath = 'my-chat.txt';
-      const result = await shareCommand?.action?.(mockContext, filePath);
-      expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: 'Invalid file format. Only .md and .json are supported.',
-      });
-    });
-
-    it('should inform if there is no conversation to share', async () => {
-      mockGetHistory.mockReturnValue([
-        { role: 'user', parts: [{ text: 'context' }] },
-        { role: 'model', parts: [{ text: 'context response' }] },
-      ]);
-      const result = await shareCommand?.action?.(mockContext, 'my-chat.json');
-      expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'info',
-        content: 'No conversation found to share.',
-      });
-    });
-
-    it('should handle errors during file writing', async () => {
-      const error = new Error('Permission denied');
-      mockFs.writeFile.mockRejectedValue(error);
-      const result = await shareCommand?.action?.(mockContext, 'my-chat.json');
-      expect(result).toEqual({
-        type: 'message',
-        messageType: 'error',
-        content: `Error sharing conversation: ${error.message}`,
-      });
-    });
-
-    it('should output valid JSON schema', async () => {
-      const filePath = 'my-chat.json';
-      await shareCommand?.action?.(mockContext, filePath);
-      const expectedPath = path.join(process.cwd(), 'my-chat.json');
-      const [actualPath, actualContent] = mockFs.writeFile.mock.calls[0];
-      expect(actualPath).toEqual(expectedPath);
-      const parsedContent = JSON.parse(actualContent);
-      expect(Array.isArray(parsedContent)).toBe(true);
-      parsedContent.forEach((item: Content) => {
-        expect(item).toHaveProperty('role');
-        expect(item).toHaveProperty('parts');
-        expect(Array.isArray(item.parts)).toBe(true);
-      });
-    });
-
-    it('should output correct markdown format', async () => {
-      const filePath = 'my-chat.md';
-      await shareCommand?.action?.(mockContext, filePath);
-      const expectedPath = path.join(process.cwd(), 'my-chat.md');
-      const [actualPath, actualContent] = mockFs.writeFile.mock.calls[0];
-      expect(actualPath).toEqual(expectedPath);
-      const entries = actualContent.split('\n\n---\n\n');
-      expect(entries.length).toBe(mockHistory.length);
-      entries.forEach((entry, index) => {
-        const { role, parts } = mockHistory[index];
-        const text = parts.map((p) => p.text).join('');
-        const roleIcon = role === 'user' ? '🧑‍💻' : '✨';
-        expect(entry).toBe(`${roleIcon} ## ${role.toUpperCase()}\n\n${text}`);
-      });
-    });
-  });
-
-  describe('serializeHistoryToMarkdown', () => {
-    it('should correctly serialize chat history to Markdown with icons', () => {
-      const history: Content[] = [
-        { role: 'user', parts: [{ text: 'Hello' }] },
-        { role: 'model', parts: [{ text: 'Hi there!' }] },
-        { role: 'user', parts: [{ text: 'How are you?' }] },
-      ];
-
-      const expectedMarkdown =
-        '🧑‍💻 ## USER\n\nHello\n\n---\n\n' +
-        '✨ ## MODEL\n\nHi there!\n\n---\n\n' +
-        '🧑‍💻 ## USER\n\nHow are you?';
-
-      const result = serializeHistoryToMarkdown(history);
-      expect(result).toBe(expectedMarkdown);
-    });
-
-    it('should handle empty history', () => {
-      const history: Content[] = [];
-      const result = serializeHistoryToMarkdown(history);
-      expect(result).toBe('');
-    });
-
-    it('should handle items with no text parts', () => {
-      const history: Content[] = [
-        { role: 'user', parts: [{ text: 'Hello' }] },
-        { role: 'model', parts: [] },
-        { role: 'user', parts: [{ text: 'How are you?' }] },
-      ];
-
-      const expectedMarkdown = `🧑‍💻 ## USER
-
-Hello
-
----
-
-✨ ## MODEL
-
-
-
----
-
-🧑‍💻 ## USER
-
-How are you?`;
-
-      const result = serializeHistoryToMarkdown(history);
-      expect(result).toBe(expectedMarkdown);
-    });
-
-    it('should correctly serialize function calls and responses', () => {
-      const history: Content[] = [
-        {
-          role: 'user',
-          parts: [{ text: 'Please call a function.' }],
-        },
-        {
-          role: 'model',
-          parts: [
-            {
-              functionCall: {
-                name: 'my-function',
-                args: { arg1: 'value1' },
-              },
-            },
-          ],
-        },
-        {
-          role: 'user',
-          parts: [
-            {
-              functionResponse: {
-                name: 'my-function',
-                response: { result: 'success' },
-              },
-            },
-          ],
-        },
-      ];
-
-      const expectedMarkdown = `🧑‍💻 ## USER
-
-Please call a function.
-
----
-
-✨ ## MODEL
-
-**Tool Command**:
-\`\`\`json
-{
-  "name": "my-function",
-  "args": {
-    "arg1": "value1"
-  }
-}
-\`\`\`
-
----
-
-🧑‍💻 ## USER
-
-**Tool Response**:
-\`\`\`json
-{
-  "name": "my-function",
-  "response": {
-    "result": "success"
-  }
-}
-\`\`\``;
-
-      const result = serializeHistoryToMarkdown(history);
-      expect(result).toBe(expectedMarkdown);
-    });
-
-    it('should handle items with undefined role', () => {
-      const history: Array<Partial<Content>> = [
-        { role: 'user', parts: [{ text: 'Hello' }] },
-        { parts: [{ text: 'Hi there!' }] },
-      ];
-
-      const expectedMarkdown = `🧑‍💻 ## USER
-
-Hello
-
----
-
-✨ ## MODEL
-
-Hi there!`;
-
-      const result = serializeHistoryToMarkdown(history as Content[]);
-      expect(result).toBe(expectedMarkdown);
-    });
-  });
-});

packages/cli/src/ui/commands/chatCommand.ts

@@ -1,419 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fsPromises from 'node:fs/promises';
-import React from 'react';
-import { Text } from 'ink';
-import type {
-  CommandContext,
-  SlashCommand,
-  MessageActionReturn,
-  SlashCommandActionReturn,
-} from './types.js';
-import { CommandKind } from './types.js';
-import { decodeTagName } from '@qwen-code/qwen-code-core';
-import path from 'node:path';
-import type { HistoryItemWithoutId } from '../types.js';
-import { MessageType } from '../types.js';
-import type { Content } from '@google/genai';
-import { t } from '../../i18n/index.js';
-
-interface ChatDetail {
-  name: string;
-  mtime: Date;
-}
-
-const getSavedChatTags = async (
-  context: CommandContext,
-  mtSortDesc: boolean,
-): Promise<ChatDetail[]> => {
-  const cfg = context.services.config;
-  const geminiDir = cfg?.storage?.getProjectTempDir();
-  if (!geminiDir) {
-    return [];
-  }
-  try {
-    const file_head = 'checkpoint-';
-    const file_tail = '.json';
-    const files = await fsPromises.readdir(geminiDir);
-    const chatDetails: Array<{ name: string; mtime: Date }> = [];
-
-    for (const file of files) {
-      if (file.startsWith(file_head) && file.endsWith(file_tail)) {
-        const filePath = path.join(geminiDir, file);
-        const stats = await fsPromises.stat(filePath);
-        const tagName = file.slice(file_head.length, -file_tail.length);
-        chatDetails.push({
-          name: decodeTagName(tagName),
-          mtime: stats.mtime,
-        });
-      }
-    }
-
-    chatDetails.sort((a, b) =>
-      mtSortDesc
-        ? b.mtime.getTime() - a.mtime.getTime()
-        : a.mtime.getTime() - b.mtime.getTime(),
-    );
-
-    return chatDetails;
-  } catch (_err) {
-    return [];
-  }
-};
-
-const listCommand: SlashCommand = {
-  name: 'list',
-  get description() {
-    return t('List saved conversation checkpoints');
-  },
-  kind: CommandKind.BUILT_IN,
-  action: async (context): Promise<MessageActionReturn> => {
-    const chatDetails = await getSavedChatTags(context, false);
-    if (chatDetails.length === 0) {
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('No saved conversation checkpoints found.'),
-      };
-    }
-
-    const maxNameLength = Math.max(
-      ...chatDetails.map((chat) => chat.name.length),
-    );
-
-    let message = t('List of saved conversations:') + '\n\n';
-    for (const chat of chatDetails) {
-      const paddedName = chat.name.padEnd(maxNameLength, ' ');
-      const isoString = chat.mtime.toISOString();
-      const match = isoString.match(/(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
-      const formattedDate = match ? `${match[1]} ${match[2]}` : 'Invalid Date';
-      message += `  - ${paddedName}  (saved on ${formattedDate})\n`;
-    }
-    message += `\n${t('Note: Newest last, oldest first')}`;
-    return {
-      type: 'message',
-      messageType: 'info',
-      content: message,
-    };
-  },
-};
-
-const saveCommand: SlashCommand = {
-  name: 'save',
-  get description() {
-    return t(
-      'Save the current conversation as a checkpoint. Usage: /chat save <tag>',
-    );
-  },
-  kind: CommandKind.BUILT_IN,
-  action: async (context, args): Promise<SlashCommandActionReturn | void> => {
-    const tag = args.trim();
-    if (!tag) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('Missing tag. Usage: /chat save <tag>'),
-      };
-    }
-
-    const { logger, config } = context.services;
-    await logger.initialize();
-
-    if (!context.overwriteConfirmed) {
-      const exists = await logger.checkpointExists(tag);
-      if (exists) {
-        return {
-          type: 'confirm_action',
-          prompt: React.createElement(
-            Text,
-            null,
-            t(
-              'A checkpoint with the tag {{tag}} already exists. Do you want to overwrite it?',
-              {
-                tag,
-              },
-            ),
-          ),
-          originalInvocation: {
-            raw: context.invocation?.raw || `/chat save ${tag}`,
-          },
-        };
-      }
-    }
-
-    const chat = await config?.getGeminiClient()?.getChat();
-    if (!chat) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('No chat client available to save conversation.'),
-      };
-    }
-
-    const history = chat.getHistory();
-    if (history.length > 2) {
-      await logger.saveCheckpoint(history, tag);
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('Conversation checkpoint saved with tag: {{tag}}.', {
-          tag: decodeTagName(tag),
-        }),
-      };
-    } else {
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('No conversation found to save.'),
-      };
-    }
-  },
-};
-
-const resumeCommand: SlashCommand = {
-  name: 'resume',
-  altNames: ['load'],
-  get description() {
-    return t(
-      'Resume a conversation from a checkpoint. Usage: /chat resume <tag>',
-    );
-  },
-  kind: CommandKind.BUILT_IN,
-  action: async (context, args) => {
-    const tag = args.trim();
-    if (!tag) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('Missing tag. Usage: /chat resume <tag>'),
-      };
-    }
-
-    const { logger } = context.services;
-    await logger.initialize();
-    const conversation = await logger.loadCheckpoint(tag);
-
-    if (conversation.length === 0) {
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('No saved checkpoint found with tag: {{tag}}.', {
-          tag: decodeTagName(tag),
-        }),
-      };
-    }
-
-    const rolemap: { [key: string]: MessageType } = {
-      user: MessageType.USER,
-      model: MessageType.GEMINI,
-    };
-
-    const uiHistory: HistoryItemWithoutId[] = [];
-    let hasSystemPrompt = false;
-    let i = 0;
-
-    for (const item of conversation) {
-      i += 1;
-      const text =
-        item.parts
-          ?.filter((m) => !!m.text)
-          .map((m) => m.text)
-          .join('') || '';
-      if (!text) {
-        continue;
-      }
-      if (i === 1 && text.match(/context for our chat/)) {
-        hasSystemPrompt = true;
-      }
-      if (i > 2 || !hasSystemPrompt) {
-        uiHistory.push({
-          type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
-          text,
-        } as HistoryItemWithoutId);
-      }
-    }
-    return {
-      type: 'load_history',
-      history: uiHistory,
-      clientHistory: conversation,
-    };
-  },
-  completion: async (context, partialArg) => {
-    const chatDetails = await getSavedChatTags(context, true);
-    return chatDetails
-      .map((chat) => chat.name)
-      .filter((name) => name.startsWith(partialArg));
-  },
-};
-
-const deleteCommand: SlashCommand = {
-  name: 'delete',
-  get description() {
-    return t('Delete a conversation checkpoint. Usage: /chat delete <tag>');
-  },
-  kind: CommandKind.BUILT_IN,
-  action: async (context, args): Promise<MessageActionReturn> => {
-    const tag = args.trim();
-    if (!tag) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('Missing tag. Usage: /chat delete <tag>'),
-      };
-    }
-
-    const { logger } = context.services;
-    await logger.initialize();
-    const deleted = await logger.deleteCheckpoint(tag);
-
-    if (deleted) {
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t("Conversation checkpoint '{{tag}}' has been deleted.", {
-          tag: decodeTagName(tag),
-        }),
-      };
-    } else {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t("Error: No checkpoint found with tag '{{tag}}'.", {
-          tag: decodeTagName(tag),
-        }),
-      };
-    }
-  },
-  completion: async (context, partialArg) => {
-    const chatDetails = await getSavedChatTags(context, true);
-    return chatDetails
-      .map((chat) => chat.name)
-      .filter((name) => name.startsWith(partialArg));
-  },
-};
-
-export function serializeHistoryToMarkdown(history: Content[]): string {
-  return history
-    .map((item) => {
-      const text =
-        item.parts
-          ?.map((part) => {
-            if (part.text) {
-              return part.text;
-            }
-            if (part.functionCall) {
-              return `**Tool Command**:\n\`\`\`json\n${JSON.stringify(
-                part.functionCall,
-                null,
-                2,
-              )}\n\`\`\``;
-            }
-            if (part.functionResponse) {
-              return `**Tool Response**:\n\`\`\`json\n${JSON.stringify(
-                part.functionResponse,
-                null,
-                2,
-              )}\n\`\`\``;
-            }
-            return '';
-          })
-          .join('') || '';
-      const roleIcon = item.role === 'user' ? '🧑‍💻' : '✨';
-      return `${roleIcon} ## ${(item.role || 'model').toUpperCase()}\n\n${text}`;
-    })
-    .join('\n\n---\n\n');
-}
-
-const shareCommand: SlashCommand = {
-  name: 'share',
-  get description() {
-    return t(
-      'Share the current conversation to a markdown or json file. Usage: /chat share <file>',
-    );
-  },
-  kind: CommandKind.BUILT_IN,
-  action: async (context, args): Promise<MessageActionReturn> => {
-    let filePathArg = args.trim();
-    if (!filePathArg) {
-      filePathArg = `gemini-conversation-${Date.now()}.json`;
-    }
-
-    const filePath = path.resolve(filePathArg);
-    const extension = path.extname(filePath);
-    if (extension !== '.md' && extension !== '.json') {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('Invalid file format. Only .md and .json are supported.'),
-      };
-    }
-
-    const chat = await context.services.config?.getGeminiClient()?.getChat();
-    if (!chat) {
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('No chat client available to share conversation.'),
-      };
-    }
-
-    const history = chat.getHistory();
-
-    // An empty conversation has two hidden messages that setup the context for
-    // the chat. Thus, to check whether a conversation has been started, we
-    // can't check for length 0.
-    if (history.length <= 2) {
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('No conversation found to share.'),
-      };
-    }
-
-    let content = '';
-    if (extension === '.json') {
-      content = JSON.stringify(history, null, 2);
-    } else {
-      content = serializeHistoryToMarkdown(history);
-    }
-
-    try {
-      await fsPromises.writeFile(filePath, content);
-      return {
-        type: 'message',
-        messageType: 'info',
-        content: t('Conversation shared to {{filePath}}', {
-          filePath,
-        }),
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        type: 'message',
-        messageType: 'error',
-        content: t('Error sharing conversation: {{error}}', {
-          error: errorMessage,
-        }),
-      };
-    }
-  },
-};
-
-export const chatCommand: SlashCommand = {
-  name: 'chat',
-  get description() {
-    return t('Manage conversation history.');
-  },
-  kind: CommandKind.BUILT_IN,
-  subCommands: [
-    listCommand,
-    saveCommand,
-    resumeCommand,
-    deleteCommand,
-    shareCommand,
-  ],
-};

packages/cli/src/ui/commands/clearCommand.test.ts

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Mock } from 'vitest';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
 import { clearCommand } from './clearCommand.js';
 import { type CommandContext } from './types.js';
@@ -16,20 +15,21 @@ vi.mock('@qwen-code/qwen-code-core', async () => {
   return {
     ...actual,
     uiTelemetryService: {
-      setLastPromptTokenCount: vi.fn(),
+      reset: vi.fn(),
     },
   };
 });
 
 import type { GeminiClient } from '@qwen-code/qwen-code-core';
-import { uiTelemetryService } from '@qwen-code/qwen-code-core';
 
 describe('clearCommand', () => {
   let mockContext: CommandContext;
   let mockResetChat: ReturnType<typeof vi.fn>;
+  let mockStartNewSession: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     mockResetChat = vi.fn().mockResolvedValue(undefined);
+    mockStartNewSession = vi.fn().mockReturnValue('new-session-id');
     vi.clearAllMocks();
 
     mockContext = createMockCommandContext({
@@ -39,12 +39,16 @@ describe('clearCommand', () => {
             ({
               resetChat: mockResetChat,
             }) as unknown as GeminiClient,
+          startNewSession: mockStartNewSession,
         },
       },
+      session: {
+        startNewSession: vi.fn(),
+      },
     });
   });
 
-  it('should set debug message, reset chat, reset telemetry, and clear UI when config is available', async () => {
+  it('should set debug message, start a new session, reset chat, and clear UI when config is available', async () => {
     if (!clearCommand.action) {
       throw new Error('clearCommand must have an action.');
     }
@@ -52,28 +56,23 @@ describe('clearCommand', () => {
     await clearCommand.action(mockContext, '');
 
     expect(mockContext.ui.setDebugMessage).toHaveBeenCalledWith(
-      'Clearing terminal and resetting chat.',
+      'Starting a new session, resetting chat, and clearing terminal.',
     );
     expect(mockContext.ui.setDebugMessage).toHaveBeenCalledTimes(1);
 
+    expect(mockStartNewSession).toHaveBeenCalledTimes(1);
+    expect(mockContext.session.startNewSession).toHaveBeenCalledWith(
+      'new-session-id',
+    );
     expect(mockResetChat).toHaveBeenCalledTimes(1);
-    expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(0);
-    expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
     expect(mockContext.ui.clear).toHaveBeenCalledTimes(1);
 
-    // Check the order of operations.
-    const setDebugMessageOrder = (mockContext.ui.setDebugMessage as Mock).mock
-      .invocationCallOrder[0];
-    const resetChatOrder = mockResetChat.mock.invocationCallOrder[0];
-    const resetTelemetryOrder = (
-      uiTelemetryService.setLastPromptTokenCount as Mock
-    ).mock.invocationCallOrder[0];
-    const clearOrder = (mockContext.ui.clear as Mock).mock
-      .invocationCallOrder[0];
-
-    expect(setDebugMessageOrder).toBeLessThan(resetChatOrder);
-    expect(resetChatOrder).toBeLessThan(resetTelemetryOrder);
-    expect(resetTelemetryOrder).toBeLessThan(clearOrder);
+    // Check that all expected operations were called
+    expect(mockContext.ui.setDebugMessage).toHaveBeenCalled();
+    expect(mockStartNewSession).toHaveBeenCalled();
+    expect(mockContext.session.startNewSession).toHaveBeenCalled();
+    expect(mockResetChat).toHaveBeenCalled();
+    expect(mockContext.ui.clear).toHaveBeenCalled();
   });
 
   it('should not attempt to reset chat if config service is not available', async () => {
@@ -85,16 +84,17 @@ describe('clearCommand', () => {
       services: {
         config: null,
       },
+      session: {
+        startNewSession: vi.fn(),
+      },
     });
 
     await clearCommand.action(nullConfigContext, '');
 
     expect(nullConfigContext.ui.setDebugMessage).toHaveBeenCalledWith(
-      'Clearing terminal.',
+      'Starting a new session and clearing.',
     );
     expect(mockResetChat).not.toHaveBeenCalled();
-    expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(0);
-    expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
     expect(nullConfigContext.ui.clear).toHaveBeenCalledTimes(1);
   });
 });

packages/cli/src/ui/commands/clearCommand.ts

@@ -4,30 +4,46 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { uiTelemetryService } from '@qwen-code/qwen-code-core';
 import type { SlashCommand } from './types.js';
 import { CommandKind } from './types.js';
 import { t } from '../../i18n/index.js';
+import { uiTelemetryService } from '@qwen-code/qwen-code-core';
 
 export const clearCommand: SlashCommand = {
   name: 'clear',
+  altNames: ['reset', 'new'],
   get description() {
-    return t('clear the screen and conversation history');
+    return t('Clear conversation history and free up context');
   },
   kind: CommandKind.BUILT_IN,
   action: async (context, _args) => {
-    const geminiClient = context.services.config?.getGeminiClient();
+    const { config } = context.services;
 
-    if (geminiClient) {
-      context.ui.setDebugMessage(t('Clearing terminal and resetting chat.'));
-      // If resetChat fails, the exception will propagate and halt the command,
-      // which is the correct behavior to signal a failure to the user.
-      await geminiClient.resetChat();
+    if (config) {
+      const newSessionId = config.startNewSession();
+
+      // Reset UI telemetry metrics for the new session
+      uiTelemetryService.reset();
+
+      if (newSessionId && context.session.startNewSession) {
+        context.session.startNewSession(newSessionId);
+      }
+
+      const geminiClient = config.getGeminiClient();
+      if (geminiClient) {
+        context.ui.setDebugMessage(
+          t('Starting a new session, resetting chat, and clearing terminal.'),
+        );
+        // If resetChat fails, the exception will propagate and halt the command,
+        // which is the correct behavior to signal a failure to the user.
+        await geminiClient.resetChat();
+      } else {
+        context.ui.setDebugMessage(t('Starting a new session and clearing.'));
+      }
     } else {
-      context.ui.setDebugMessage(t('Clearing terminal.'));
+      context.ui.setDebugMessage(t('Starting a new session and clearing.'));
     }
 
-    uiTelemetryService.setLastPromptTokenCount(0);
     context.ui.clear();
   },
 };

packages/cli/src/ui/commands/quitCommand.ts

@@ -8,35 +8,6 @@ import { formatDuration } from '../utils/formatters.js';
 import { CommandKind, type SlashCommand } from './types.js';
 import { t } from '../../i18n/index.js';
 
-export const quitConfirmCommand: SlashCommand = {
-  name: 'quit-confirm',
-  get description() {
-    return t('Show quit confirmation dialog');
-  },
-  kind: CommandKind.BUILT_IN,
-  action: (context) => {
-    const now = Date.now();
-    const { sessionStartTime } = context.session.stats;
-    const wallDuration = now - sessionStartTime.getTime();
-
-    return {
-      type: 'quit_confirmation',
-      messages: [
-        {
-          type: 'user',
-          text: `/quit-confirm`,
-          id: now - 1,
-        },
-        {
-          type: 'quit_confirmation',
-          duration: formatDuration(wallDuration),
-          id: now,
-        },
-      ],
-    };
-  },
-};
-
 export const quitCommand: SlashCommand = {
   name: 'quit',
   altNames: ['exit'],

packages/cli/src/ui/commands/types.ts

@@ -37,7 +37,7 @@ export interface CommandContext {
     config: Config | null;
     settings: LoadedSettings;
     git: GitService | undefined;
-    logger: Logger;
+    logger: Logger | null;
   };
   // UI state and history management
   ui: {
@@ -78,6 +78,8 @@ export interface CommandContext {
     stats: SessionStatsState;
     /** A transient list of shell commands the user has approved for this session. */
     sessionShellAllowlist: Set<string>;
+    /** Reset session metrics and prompt counters for a fresh session. */
+    startNewSession?: (sessionId: string) => void;
   };
   // Flag to indicate if an overwrite has been confirmed
   overwriteConfirmed?: boolean;
@@ -98,12 +100,6 @@ export interface QuitActionReturn {
   messages: HistoryItem[];
 }
 
-/** The return type for a command action that requests quit confirmation. */
-export interface QuitConfirmationActionReturn {
-  type: 'quit_confirmation';
-  messages: HistoryItem[];
-}
-
 /**
  * The return type for a command action that results in a simple message
  * being displayed to the user.
@@ -180,7 +176,6 @@ export type SlashCommandActionReturn =
   | ToolActionReturn
   | MessageActionReturn
   | QuitActionReturn
-  | QuitConfirmationActionReturn
   | OpenDialogActionReturn
   | LoadHistoryActionReturn
   | SubmitPromptActionReturn
@@ -214,7 +209,7 @@ export interface SlashCommand {
     | SlashCommandActionReturn
     | Promise<void | SlashCommandActionReturn>;
 
-  // Provides argument completion (e.g., completing a tag for `/chat resume <tag>`).
+  // Provides argument completion
   completion?: (
     context: CommandContext,
     partialArg: string,

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

@@ -36,10 +36,6 @@ import { WelcomeBackDialog } from './WelcomeBackDialog.js';
 import { ModelSwitchDialog } from './ModelSwitchDialog.js';
 import { AgentCreationWizard } from './subagents/create/AgentCreationWizard.js';
 import { AgentsManagerDialog } from './subagents/manage/AgentsManagerDialog.js';
-import {
-  QuitConfirmationDialog,
-  QuitChoice,
-} from './QuitConfirmationDialog.js';
 
 interface DialogManagerProps {
   addItem: UseHistoryManagerReturn['addItem'];
@@ -127,26 +123,6 @@ export const DialogManager = ({
       />
     );
   }
-  if (uiState.quitConfirmationRequest) {
-    return (
-      <QuitConfirmationDialog
-        onSelect={(choice: QuitChoice) => {
-          if (choice === QuitChoice.CANCEL) {
-            uiState.quitConfirmationRequest?.onConfirm(false, 'cancel');
-          } else if (choice === QuitChoice.QUIT) {
-            uiState.quitConfirmationRequest?.onConfirm(true, 'quit');
-          } else if (choice === QuitChoice.SAVE_AND_QUIT) {
-            uiState.quitConfirmationRequest?.onConfirm(true, 'save_and_quit');
-          } else if (choice === QuitChoice.SUMMARY_AND_QUIT) {
-            uiState.quitConfirmationRequest?.onConfirm(
-              true,
-              'summary_and_quit',
-            );
-          }
-        }}
-      />
-    );
-  }
   if (uiState.confirmationRequest) {
     return (
       <ConsentPrompt

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

@@ -17,6 +17,7 @@ const mockCommands: readonly SlashCommand[] = [
     name: 'test',
     description: 'A test command',
     kind: CommandKind.BUILT_IN,
+    altNames: ['alias-one', 'alias-two'],
   },
   {
     name: 'hidden',
@@ -60,4 +61,11 @@ describe('Help Component', () => {
     expect(output).toContain('visible-child');
     expect(output).not.toContain('hidden-child');
   });
+
+  it('should render alt names for commands when available', () => {
+    const { lastFrame } = render(<Help commands={mockCommands} />);
+    const output = lastFrame();
+
+    expect(output).toContain('/test (alias-one, alias-two)');
+  });
 });

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

@@ -67,7 +67,7 @@ export const Help: React.FC<Help> = ({ commands }) => (
           <Text color={theme.text.primary}>
             <Text bold color={theme.text.accent}>
               {' '}
-              /{command.name}
+              {formatCommandLabel(command, '/')}
             </Text>
             {command.kind === CommandKind.MCP_PROMPT && (
               <Text color={theme.text.secondary}> [MCP]</Text>
@@ -81,7 +81,7 @@ export const Help: React.FC<Help> = ({ commands }) => (
                 <Text key={subCommand.name} color={theme.text.primary}>
                   <Text bold color={theme.text.accent}>
                     {'   '}
-                    {subCommand.name}
+                    {formatCommandLabel(subCommand)}
                   </Text>
                   {subCommand.description && ' - ' + subCommand.description}
                 </Text>
@@ -171,3 +171,17 @@ export const Help: React.FC<Help> = ({ commands }) => (
     </Text>
   </Box>
 );
+
+/**
+ * Builds a display label for a slash command, including any alternate names.
+ */
+function formatCommandLabel(command: SlashCommand, prefix = ''): string {
+  const altNames = command.altNames?.filter(Boolean);
+  const baseLabel = `${prefix}${command.name}`;
+
+  if (!altNames || altNames.length === 0) {
+    return baseLabel;
+  }
+
+  return `${baseLabel} (${altNames.join(', ')})`;
+}

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

@@ -15,6 +15,8 @@ import { InfoMessage } from './messages/InfoMessage.js';
 import { ErrorMessage } from './messages/ErrorMessage.js';
 import { ToolGroupMessage } from './messages/ToolGroupMessage.js';
 import { GeminiMessageContent } from './messages/GeminiMessageContent.js';
+import { GeminiThoughtMessage } from './messages/GeminiThoughtMessage.js';
+import { GeminiThoughtMessageContent } from './messages/GeminiThoughtMessageContent.js';
 import { CompressionMessage } from './messages/CompressionMessage.js';
 import { SummaryMessage } from './messages/SummaryMessage.js';
 import { WarningMessage } from './messages/WarningMessage.js';
@@ -85,6 +87,26 @@ const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
           terminalWidth={terminalWidth}
         />
       )}
+      {itemForDisplay.type === 'gemini_thought' && (
+        <GeminiThoughtMessage
+          text={itemForDisplay.text}
+          isPending={isPending}
+          availableTerminalHeight={
+            availableTerminalHeightGemini ?? availableTerminalHeight
+          }
+          terminalWidth={terminalWidth}
+        />
+      )}
+      {itemForDisplay.type === 'gemini_thought_content' && (
+        <GeminiThoughtMessageContent
+          text={itemForDisplay.text}
+          isPending={isPending}
+          availableTerminalHeight={
+            availableTerminalHeightGemini ?? availableTerminalHeight
+          }
+          terminalWidth={terminalWidth}
+        />
+      )}
       {itemForDisplay.type === 'info' && (
         <InfoMessage text={itemForDisplay.text} />
       )}
@@ -108,9 +130,6 @@ const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
       {itemForDisplay.type === 'quit' && (
         <SessionSummaryDisplay duration={itemForDisplay.duration} />
       )}
-      {itemForDisplay.type === 'quit_confirmation' && (
-        <SessionSummaryDisplay duration={itemForDisplay.duration} />
-      )}
       {itemForDisplay.type === 'tool_group' && (
         <ToolGroupMessage
           toolCalls={itemForDisplay.tools}

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

@@ -66,20 +66,6 @@ const mockSlashCommands: SlashCommand[] = [
       },
     ],
   },
-  {
-    name: 'chat',
-    description: 'Manage chats',
-    kind: CommandKind.BUILT_IN,
-    subCommands: [
-      {
-        name: 'resume',
-        description: 'Resume a chat',
-        kind: CommandKind.BUILT_IN,
-        action: vi.fn(),
-        completion: async () => ['fix-foo', 'fix-bar'],
-      },
-    ],
-  },
 ];
 
 describe('InputPrompt', () => {
@@ -571,14 +557,14 @@ describe('InputPrompt', () => {
   });
 
   it('should complete a partial argument for a command', async () => {
-    // SCENARIO: /chat resume fi- -> Tab
+    // SCENARIO: /memory add fi- -> Tab
     mockedUseCommandCompletion.mockReturnValue({
       ...mockCommandCompletion,
       showSuggestions: true,
       suggestions: [{ label: 'fix-foo', value: 'fix-foo' }],
       activeSuggestionIndex: 0,
     });
-    props.buffer.setText('/chat resume fi-');
+    props.buffer.setText('/memory add fi-');
 
     const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
     await wait();

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

@@ -1,79 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { Box, Text } from 'ink';
-import type React from 'react';
-import { Colors } from '../colors.js';
-import {
-  RadioButtonSelect,
-  type RadioSelectItem,
-} from './shared/RadioButtonSelect.js';
-import { useKeypress } from '../hooks/useKeypress.js';
-import { t } from '../../i18n/index.js';
-
-export enum QuitChoice {
-  CANCEL = 'cancel',
-  QUIT = 'quit',
-  SAVE_AND_QUIT = 'save_and_quit',
-  SUMMARY_AND_QUIT = 'summary_and_quit',
-}
-
-interface QuitConfirmationDialogProps {
-  onSelect: (choice: QuitChoice) => void;
-}
-
-export const QuitConfirmationDialog: React.FC<QuitConfirmationDialogProps> = ({
-  onSelect,
-}) => {
-  useKeypress(
-    (key) => {
-      if (key.name === 'escape') {
-        onSelect(QuitChoice.CANCEL);
-      }
-    },
-    { isActive: true },
-  );
-
-  const options: Array<RadioSelectItem<QuitChoice>> = [
-    {
-      key: 'quit',
-      label: t('Quit immediately (/quit)'),
-      value: QuitChoice.QUIT,
-    },
-    {
-      key: 'summary-and-quit',
-      label: t('Generate summary and quit (/summary)'),
-      value: QuitChoice.SUMMARY_AND_QUIT,
-    },
-    {
-      key: 'save-and-quit',
-      label: t('Save conversation and quit (/chat save)'),
-      value: QuitChoice.SAVE_AND_QUIT,
-    },
-    {
-      key: 'cancel',
-      label: t('Cancel (stay in application)'),
-      value: QuitChoice.CANCEL,
-    },
-  ];
-
-  return (
-    <Box
-      flexDirection="column"
-      borderStyle="round"
-      borderColor={Colors.AccentYellow}
-      padding={1}
-      width="100%"
-      marginLeft={1}
-    >
-      <Box flexDirection="column" marginBottom={1}>
-        <Text>{t('What would you like to do before exiting?')}</Text>
-      </Box>
-
-      <RadioButtonSelect items={options} onSelect={onSelect} isFocused />
-    </Box>
-  );
-};

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

@@ -0,0 +1,436 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import {
+  SessionService,
+  type SessionListItem,
+  type ListSessionsResult,
+  getGitBranch,
+} from '@qwen-code/qwen-code-core';
+import { theme } from '../semantic-colors.js';
+import { formatRelativeTime } from '../utils/formatters.js';
+
+const PAGE_SIZE = 20;
+
+interface SessionPickerProps {
+  sessionService: SessionService;
+  currentBranch?: string;
+  onSelect: (sessionId: string) => void;
+  onCancel: () => void;
+}
+
+/**
+ * Truncates text to fit within a given width, adding ellipsis if needed.
+ */
+function truncateText(text: string, maxWidth: number): string {
+  if (text.length <= maxWidth) return text;
+  if (maxWidth <= 3) return text.slice(0, maxWidth);
+  return text.slice(0, maxWidth - 3) + '...';
+}
+
+function SessionPicker({
+  sessionService,
+  currentBranch,
+  onSelect,
+  onCancel,
+}: SessionPickerProps): React.JSX.Element {
+  const { exit } = useApp();
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [sessionState, setSessionState] = useState<{
+    sessions: SessionListItem[];
+    hasMore: boolean;
+    nextCursor?: number;
+  }>({
+    sessions: [],
+    hasMore: true,
+    nextCursor: undefined,
+  });
+  const isLoadingMoreRef = useRef(false);
+  const [filterByBranch, setFilterByBranch] = useState(false);
+  const [isExiting, setIsExiting] = useState(false);
+  const [terminalSize, setTerminalSize] = useState({
+    width: process.stdout.columns || 80,
+    height: process.stdout.rows || 24,
+  });
+
+  // Update terminal size on resize
+  useEffect(() => {
+    const handleResize = () => {
+      setTerminalSize({
+        width: process.stdout.columns || 80,
+        height: process.stdout.rows || 24,
+      });
+    };
+    process.stdout.on('resize', handleResize);
+    return () => {
+      process.stdout.off('resize', handleResize);
+    };
+  }, []);
+
+  // Filter sessions by current branch if filter is enabled
+  const filteredSessions =
+    filterByBranch && currentBranch
+      ? sessionState.sessions.filter(
+          (session) => session.gitBranch === currentBranch,
+        )
+      : sessionState.sessions;
+
+  const hasSentinel = sessionState.hasMore;
+
+  // Reset selection when filter changes
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [filterByBranch]);
+
+  const loadMoreSessions = useCallback(async () => {
+    if (!sessionState.hasMore || isLoadingMoreRef.current) return;
+    isLoadingMoreRef.current = true;
+    try {
+      const result: ListSessionsResult = await sessionService.listSessions({
+        size: PAGE_SIZE,
+        cursor: sessionState.nextCursor,
+      });
+
+      setSessionState((prev) => ({
+        sessions: [...prev.sessions, ...result.items],
+        hasMore: result.hasMore && result.nextCursor !== undefined,
+        nextCursor: result.nextCursor,
+      }));
+    } finally {
+      isLoadingMoreRef.current = false;
+    }
+  }, [sessionService, sessionState.hasMore, sessionState.nextCursor]);
+
+  // Calculate visible items
+  // Reserved space: header (1), footer (1), separators (2), borders (2)
+  const reservedLines = 6;
+  // Each item takes 2 lines (prompt + metadata) + 1 line margin between items
+  // On average, this is ~3 lines per item, but the last item has no margin
+  const itemHeight = 3;
+  const maxVisibleItems = Math.max(
+    1,
+    Math.floor((terminalSize.height - reservedLines) / itemHeight),
+  );
+
+  // Calculate scroll offset
+  const scrollOffset = (() => {
+    if (filteredSessions.length <= maxVisibleItems) return 0;
+    const halfVisible = Math.floor(maxVisibleItems / 2);
+    let offset = selectedIndex - halfVisible;
+    offset = Math.max(0, offset);
+    offset = Math.min(filteredSessions.length - maxVisibleItems, offset);
+    return offset;
+  })();
+
+  const visibleSessions = filteredSessions.slice(
+    scrollOffset,
+    scrollOffset + maxVisibleItems,
+  );
+  const showScrollUp = scrollOffset > 0;
+  const showScrollDown =
+    scrollOffset + maxVisibleItems < filteredSessions.length;
+
+  // Sentinel (invisible) sits after the last session item; consider it visible
+  // once the viewport reaches the final real item.
+  const sentinelVisible =
+    hasSentinel && scrollOffset + maxVisibleItems >= filteredSessions.length;
+
+  // Load more when sentinel enters view or when filtered list is empty.
+  useEffect(() => {
+    if (!sessionState.hasMore || isLoadingMoreRef.current) return;
+
+    const shouldLoadMore =
+      filteredSessions.length === 0 ||
+      sentinelVisible ||
+      isLoadingMoreRef.current;
+
+    if (shouldLoadMore) {
+      void loadMoreSessions();
+    }
+  }, [
+    filteredSessions.length,
+    loadMoreSessions,
+    sessionState.hasMore,
+    sentinelVisible,
+  ]);
+
+  // Handle keyboard input
+  useInput((input, key) => {
+    // Ignore input if already exiting
+    if (isExiting) {
+      return;
+    }
+
+    // Escape or Ctrl+C to cancel
+    if (key.escape || (key.ctrl && input === 'c')) {
+      setIsExiting(true);
+      onCancel();
+      exit();
+      return;
+    }
+
+    if (key.return) {
+      const session = filteredSessions[selectedIndex];
+      if (session) {
+        setIsExiting(true);
+        onSelect(session.sessionId);
+        exit();
+      }
+      return;
+    }
+
+    if (key.upArrow || input === 'k') {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+      return;
+    }
+
+    if (key.downArrow || input === 'j') {
+      if (filteredSessions.length === 0) {
+        return;
+      }
+      setSelectedIndex((prev) =>
+        Math.min(filteredSessions.length - 1, prev + 1),
+      );
+      return;
+    }
+
+    if (input === 'b' || input === 'B') {
+      if (currentBranch) {
+        setFilterByBranch((prev) => !prev);
+      }
+      return;
+    }
+  });
+
+  // Filtered sessions may have changed, ensure selectedIndex is valid
+  useEffect(() => {
+    if (
+      selectedIndex >= filteredSessions.length &&
+      filteredSessions.length > 0
+    ) {
+      setSelectedIndex(filteredSessions.length - 1);
+    }
+  }, [filteredSessions.length, selectedIndex]);
+
+  // Calculate content width (terminal width minus border padding)
+  const contentWidth = terminalSize.width - 4;
+  const promptMaxWidth = contentWidth - 4; // Account for "› " prefix
+
+  // Return empty while exiting to prevent visual glitches
+  if (isExiting) {
+    return <Box />;
+  }
+
+  return (
+    <Box
+      flexDirection="column"
+      width={terminalSize.width}
+      height={terminalSize.height - 1}
+      overflow="hidden"
+    >
+      {/* Main container with single border */}
+      <Box
+        flexDirection="column"
+        borderStyle="round"
+        borderColor={theme.border.default}
+        width={terminalSize.width}
+        height={terminalSize.height - 1}
+        overflow="hidden"
+      >
+        {/* Header row */}
+        <Box paddingX={1}>
+          <Text bold color={theme.text.primary}>
+            Resume Session
+          </Text>
+        </Box>
+
+        {/* Separator line */}
+        <Box>
+          <Text color={theme.border.default}>
+            {'─'.repeat(terminalSize.width - 2)}
+          </Text>
+        </Box>
+
+        {/* Session list with auto-scrolling */}
+        <Box flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
+          {filteredSessions.length === 0 ? (
+            <Box paddingY={1} justifyContent="center">
+              <Text color={theme.text.secondary}>
+                {filterByBranch
+                  ? `No sessions found for branch "${currentBranch}"`
+                  : 'No sessions found'}
+              </Text>
+            </Box>
+          ) : (
+            visibleSessions.map((session, visibleIndex) => {
+              const actualIndex = scrollOffset + visibleIndex;
+              const isSelected = actualIndex === selectedIndex;
+              const isFirst = visibleIndex === 0;
+              const isLast = visibleIndex === visibleSessions.length - 1;
+              const timeAgo = formatRelativeTime(session.mtime);
+              const messageText =
+                session.messageCount === 1
+                  ? '1 message'
+                  : `${session.messageCount} messages`;
+
+              // Show scroll indicator on first/last visible items
+              const showUpIndicator = isFirst && showScrollUp;
+              const showDownIndicator = isLast && showScrollDown;
+
+              // Determine the prefix: selector takes priority over scroll indicator
+              const prefix = isSelected
+                ? '› '
+                : showUpIndicator
+                  ? '↑ '
+                  : showDownIndicator
+                    ? '↓ '
+                    : '  ';
+
+              return (
+                <Box
+                  key={session.sessionId}
+                  flexDirection="column"
+                  marginBottom={isLast ? 0 : 1}
+                >
+                  {/* First line: prefix (selector or scroll indicator) + prompt text */}
+                  <Box>
+                    <Text
+                      color={
+                        isSelected
+                          ? theme.text.accent
+                          : showUpIndicator || showDownIndicator
+                            ? theme.text.secondary
+                            : undefined
+                      }
+                    >
+                      {prefix}
+                    </Text>
+                    <Text
+                      bold={isSelected}
+                      color={
+                        isSelected ? theme.text.accent : theme.text.primary
+                      }
+                    >
+                      {truncateText(
+                        session.prompt || '(empty prompt)',
+                        promptMaxWidth,
+                      )}
+                    </Text>
+                  </Box>
+
+                  {/* Second line: metadata (aligned with prompt text) */}
+                  <Box>
+                    <Text>{'  '}</Text>
+                    <Text color={theme.text.secondary}>
+                      {timeAgo} · {messageText}
+                      {session.gitBranch && ` · ${session.gitBranch}`}
+                    </Text>
+                  </Box>
+                </Box>
+              );
+            })
+          )}
+        </Box>
+
+        {/* Separator line */}
+        <Box>
+          <Text color={theme.border.default}>
+            {'─'.repeat(terminalSize.width - 2)}
+          </Text>
+        </Box>
+
+        {/* Footer with keyboard shortcuts */}
+        <Box paddingX={1}>
+          <Text color={theme.text.secondary}>
+            {currentBranch && (
+              <>
+                <Text
+                  bold={filterByBranch}
+                  color={filterByBranch ? theme.text.accent : undefined}
+                >
+                  B
+                </Text>
+                {' to toggle branch · '}
+              </>
+            )}
+            {'↑↓ to navigate · Esc to cancel'}
+          </Text>
+        </Box>
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * Clears the terminal screen.
+ */
+function clearScreen(): void {
+  // Move cursor to home position and clear screen
+  process.stdout.write('\x1b[2J\x1b[H');
+}
+
+/**
+ * Shows an interactive session picker and returns the selected session ID.
+ * Returns undefined if the user cancels or no sessions are available.
+ */
+export async function showResumeSessionPicker(
+  cwd: string = process.cwd(),
+): Promise<string | undefined> {
+  const sessionService = new SessionService(cwd);
+  const hasSession = await sessionService.loadLastSession();
+  if (!hasSession) {
+    console.log('No sessions found. Start a new session with `qwen`.');
+    return undefined;
+  }
+
+  const currentBranch = getGitBranch(cwd);
+
+  // Clear the screen before showing the picker for a clean fullscreen experience
+  clearScreen();
+
+  // Enable raw mode for keyboard input if not already enabled
+  const wasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY && !wasRaw) {
+    process.stdin.setRawMode(true);
+  }
+
+  return new Promise<string | undefined>((resolve) => {
+    let selectedId: string | undefined;
+
+    const { unmount, waitUntilExit } = render(
+      <SessionPicker
+        sessionService={sessionService}
+        currentBranch={currentBranch}
+        onSelect={(id) => {
+          selectedId = id;
+        }}
+        onCancel={() => {
+          selectedId = undefined;
+        }}
+      />,
+      {
+        exitOnCtrlC: false,
+      },
+    );
+
+    waitUntilExit().then(() => {
+      unmount();
+
+      // Clear the screen after the picker closes for a clean fullscreen experience
+      clearScreen();
+
+      // Restore raw mode state only if we changed it and user cancelled
+      // (if user selected a session, main app will handle raw mode)
+      if (process.stdin.isTTY && !wasRaw && !selectedId) {
+        process.stdin.setRawMode(false);
+      }
+
+      resolve(selectedId);
+    });
+  });
+}

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

@@ -78,10 +78,11 @@ export function SuggestionsDisplay({
         const isActive = originalIndex === activeIndex;
         const isExpanded = originalIndex === expandedIndex;
         const textColor = isActive ? theme.text.accent : theme.text.secondary;
-        const isLong = suggestion.value.length >= MAX_WIDTH;
+        const displayLabel = suggestion.label ?? suggestion.value;
+        const isLong = displayLabel.length >= MAX_WIDTH;
         const labelElement = (
           <PrepareLabel
-            label={suggestion.value}
+            label={displayLabel}
             matchedIndex={suggestion.matchedIndex}
             userInput={userInput}
             textColor={textColor}

packages/cli/src/ui/components/messages/GeminiThoughtMessage.tsx

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type React from 'react';
+import { Text, Box } from 'ink';
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { theme } from '../../semantic-colors.js';
+
+interface GeminiThoughtMessageProps {
+  text: string;
+  isPending: boolean;
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+}
+
+/**
+ * Displays model thinking/reasoning text with a softer, dimmed style
+ * to visually distinguish it from regular content output.
+ */
+export const GeminiThoughtMessage: React.FC<GeminiThoughtMessageProps> = ({
+  text,
+  isPending,
+  availableTerminalHeight,
+  terminalWidth,
+}) => {
+  const prefix = '✦ ';
+  const prefixWidth = prefix.length;
+
+  return (
+    <Box flexDirection="row" marginBottom={1}>
+      <Box width={prefixWidth}>
+        <Text color={theme.text.secondary}>{prefix}</Text>
+      </Box>
+      <Box flexGrow={1} flexDirection="column">
+        <MarkdownDisplay
+          text={text}
+          isPending={isPending}
+          availableTerminalHeight={availableTerminalHeight}
+          terminalWidth={terminalWidth}
+          textColor={theme.text.secondary}
+        />
+      </Box>
+    </Box>
+  );
+};

packages/cli/src/ui/components/messages/GeminiThoughtMessageContent.tsx

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type React from 'react';
+import { Box } from 'ink';
+import { MarkdownDisplay } from '../../utils/MarkdownDisplay.js';
+import { theme } from '../../semantic-colors.js';
+
+interface GeminiThoughtMessageContentProps {
+  text: string;
+  isPending: boolean;
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+}
+
+/**
+ * Continuation component for thought messages, similar to GeminiMessageContent.
+ * Used when a thought response gets too long and needs to be split for performance.
+ */
+export const GeminiThoughtMessageContent: React.FC<
+  GeminiThoughtMessageContentProps
+> = ({ text, isPending, availableTerminalHeight, terminalWidth }) => {
+  const originalPrefix = '✦ ';
+  const prefixWidth = originalPrefix.length;
+
+  return (
+    <Box flexDirection="column" paddingLeft={prefixWidth} marginBottom={1}>
+      <MarkdownDisplay
+        text={text}
+        isPending={isPending}
+        availableTerminalHeight={availableTerminalHeight}
+        terminalWidth={terminalWidth}
+        textColor={theme.text.secondary}
+      />
+    </Box>
+  );
+};

packages/cli/src/ui/components/subagents/manage/AgentEditStep.tsx

@@ -69,7 +69,10 @@ export function EditOptionsStep({
       if (selectedValue === 'editor') {
         // Launch editor directly
         try {
-          await launchEditor(selectedAgent?.filePath);
+          if (!selectedAgent.filePath) {
+            throw new Error('Agent has no file path');
+          }
+          await launchEditor(selectedAgent.filePath);
         } catch (err) {
           setError(
             t('Failed to launch editor: {{error}}', {

packages/cli/src/ui/components/subagents/manage/AgentSelectionStep.tsx

@@ -218,7 +218,7 @@ export const AgentSelectionStep = ({
   const renderAgentItem = (
     agent: {
       name: string;
-      level: 'project' | 'user' | 'builtin';
+      level: 'project' | 'user' | 'builtin' | 'session';
       isBuiltin?: boolean;
     },
     index: number,
@@ -267,7 +267,7 @@ export const AgentSelectionStep = ({
         <Box flexDirection="column" marginBottom={1}>
           <Text color={theme.text.primary} bold>
             {t('Project Level ({{path}})', {
-              path: projectAgents[0].filePath.replace(/\/[^/]+$/, ''),
+              path: projectAgents[0].filePath?.replace(/\/[^/]+$/, '') || '',
             })}
           </Text>
           <Box marginTop={1} flexDirection="column">
@@ -289,7 +289,7 @@ export const AgentSelectionStep = ({
         >
           <Text color={theme.text.primary} bold>
             {t('User Level ({{path}})', {
-              path: userAgents[0].filePath.replace(/\/[^/]+$/, ''),
+              path: userAgents[0].filePath?.replace(/\/[^/]+$/, '') || '',
             })}
           </Text>
           <Box marginTop={1} flexDirection="column">

packages/cli/src/ui/contexts/SessionContext.test.tsx

@@ -84,6 +84,7 @@ describe('SessionStatsContext', () => {
           accept: 1,
           reject: 0,
           modify: 0,
+          auto_accept: 0,
         },
         byName: {
           'test-tool': {
@@ -95,10 +96,15 @@ describe('SessionStatsContext', () => {
               accept: 1,
               reject: 0,
               modify: 0,
+              auto_accept: 0,
             },
           },
         },
       },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
     };
 
     act(() => {
@@ -152,9 +158,13 @@ describe('SessionStatsContext', () => {
         totalSuccess: 0,
         totalFail: 0,
         totalDurationMs: 0,
-        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+        totalDecisions: { accept: 0, reject: 0, modify: 0, auto_accept: 0 },
         byName: {},
       },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
     };
 
     act(() => {

packages/cli/src/ui/contexts/SessionContext.tsx

@@ -19,7 +19,7 @@ import type {
   ModelMetrics,
   ToolCallStats,
 } from '@qwen-code/qwen-code-core';
-import { uiTelemetryService, sessionId } from '@qwen-code/qwen-code-core';
+import { uiTelemetryService } from '@qwen-code/qwen-code-core';
 
 export enum ToolCallDecision {
   ACCEPT = 'accept',
@@ -168,6 +168,7 @@ export interface ComputedSessionStats {
 // and the functions to update it.
 interface SessionStatsContextValue {
   stats: SessionStatsState;
+  startNewSession: (sessionId: string) => void;
   startNewPrompt: () => void;
   getPromptCount: () => number;
 }
@@ -178,18 +179,23 @@ const SessionStatsContext = createContext<SessionStatsContextValue | undefined>(
   undefined,
 );
 
+const createDefaultStats = (sessionId: string = ''): SessionStatsState => ({
+  sessionId,
+  sessionStartTime: new Date(),
+  metrics: uiTelemetryService.getMetrics(),
+  lastPromptTokenCount: 0,
+  promptCount: 0,
+});
+
 // --- Provider Component ---
 
-export const SessionStatsProvider: React.FC<{ children: React.ReactNode }> = ({
-  children,
-}) => {
-  const [stats, setStats] = useState<SessionStatsState>({
-    sessionId,
-    sessionStartTime: new Date(),
-    metrics: uiTelemetryService.getMetrics(),
-    lastPromptTokenCount: 0,
-    promptCount: 0,
-  });
+export const SessionStatsProvider: React.FC<{
+  sessionId?: string;
+  children: React.ReactNode;
+}> = ({ sessionId, children }) => {
+  const [stats, setStats] = useState<SessionStatsState>(() =>
+    createDefaultStats(sessionId ?? ''),
+  );
 
   useEffect(() => {
     const handleUpdate = ({
@@ -226,6 +232,13 @@ export const SessionStatsProvider: React.FC<{ children: React.ReactNode }> = ({
     };
   }, []);
 
+  const startNewSession = useCallback((sessionId: string) => {
+    setStats(() => ({
+      ...createDefaultStats(sessionId),
+      lastPromptTokenCount: uiTelemetryService.getLastPromptTokenCount(),
+    }));
+  }, []);
+
   const startNewPrompt = useCallback(() => {
     setStats((prevState) => ({
       ...prevState,
@@ -241,10 +254,11 @@ export const SessionStatsProvider: React.FC<{ children: React.ReactNode }> = ({
   const value = useMemo(
     () => ({
       stats,
+      startNewSession,
       startNewPrompt,
       getPromptCount,
     }),
-    [stats, startNewPrompt, getPromptCount],
+    [stats, startNewSession, startNewPrompt, getPromptCount],
   );
 
   return (

packages/cli/src/ui/contexts/UIStateContext.tsx

@@ -12,7 +12,6 @@ import type {
   ShellConfirmationRequest,
   ConfirmationRequest,
   LoopDetectionConfirmationRequest,
-  QuitConfirmationRequest,
   HistoryItemWithoutId,
   StreamingState,
 } from '../types.js';
@@ -69,7 +68,6 @@ export interface UIState {
   confirmationRequest: ConfirmationRequest | null;
   confirmUpdateExtensionRequests: ConfirmationRequest[];
   loopDetectionConfirmationRequest: LoopDetectionConfirmationRequest | null;
-  quitConfirmationRequest: QuitConfirmationRequest | null;
   geminiMdFileCount: number;
   streamingState: StreamingState;
   initError: string | null;

packages/cli/src/ui/hooks/slashCommandProcessor.test.ts

@@ -110,6 +110,9 @@ describe('useSlashCommandProcessor', () => {
   const mockSetQuittingMessages = vi.fn();
 
   const mockConfig = makeFakeConfig({});
+  mockConfig.getChatRecordingService = vi.fn().mockReturnValue({
+    recordSlashCommand: vi.fn(),
+  });
   const mockSettings = {} as LoadedSettings;
 
   beforeEach(() => {
@@ -305,11 +308,15 @@ describe('useSlashCommandProcessor', () => {
 
       expect(childAction).toHaveBeenCalledWith(
         expect.objectContaining({
+          invocation: expect.objectContaining({
+            name: 'child',
+            args: 'with args',
+          }),
           services: expect.objectContaining({
             config: mockConfig,
           }),
           ui: expect.objectContaining({
-            addItem: mockAddItem,
+            addItem: expect.any(Function),
           }),
         }),
         'with args',
@@ -911,7 +918,6 @@ describe('useSlashCommandProcessor', () => {
           vi.fn(), // toggleVimEnabled
           vi.fn(), // setIsProcessing
           vi.fn(), // setGeminiMdFileCount
-          vi.fn(), // _showQuitConfirmation
         ),
       );
 

packages/cli/src/ui/hooks/slashCommandProcessor.ts

@@ -6,21 +6,18 @@
 
 import { useCallback, useMemo, useEffect, useState } from 'react';
 import { type PartListUnion } from '@google/genai';
-import process from 'node:process';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
-import type { Config } from '@qwen-code/qwen-code-core';
 import {
+  type Logger,
+  type Config,
   GitService,
-  Logger,
   logSlashCommand,
   makeSlashCommandEvent,
   SlashCommandStatus,
   ToolConfirmationOutcome,
-  Storage,
   IdeClient,
 } from '@qwen-code/qwen-code-core';
 import { useSessionStats } from '../contexts/SessionContext.js';
-import { formatDuration } from '../utils/formatters.js';
 import type {
   Message,
   HistoryItemWithoutId,
@@ -41,6 +38,26 @@ import {
   type ExtensionUpdateStatus,
 } from '../state/extensions.js';
 
+type SerializableHistoryItem = Record<string, unknown>;
+
+function serializeHistoryItemForRecording(
+  item: Omit<HistoryItem, 'id'>,
+): SerializableHistoryItem {
+  const clone: SerializableHistoryItem = { ...item };
+  if ('timestamp' in clone && clone['timestamp'] instanceof Date) {
+    clone['timestamp'] = clone['timestamp'].toISOString();
+  }
+  return clone;
+}
+
+const SLASH_COMMANDS_SKIP_RECORDING = new Set([
+  'quit',
+  'exit',
+  'clear',
+  'reset',
+  'new',
+]);
+
 interface SlashCommandProcessorActions {
   openAuthDialog: () => void;
   openThemeDialog: () => void;
@@ -56,7 +73,6 @@ interface SlashCommandProcessorActions {
   addConfirmUpdateExtensionRequest: (request: ConfirmationRequest) => void;
   openSubagentCreateDialog: () => void;
   openAgentsManagerDialog: () => void;
-  _showQuitConfirmation: () => void;
 }
 
 /**
@@ -75,8 +91,9 @@ export const useSlashCommandProcessor = (
   actions: SlashCommandProcessorActions,
   extensionsUpdateState: Map<string, ExtensionUpdateStatus>,
   isConfigInitialized: boolean,
+  logger: Logger | null,
 ) => {
-  const session = useSessionStats();
+  const { stats: sessionStats, startNewSession } = useSessionStats();
   const [commands, setCommands] = useState<readonly SlashCommand[]>([]);
   const [reloadTrigger, setReloadTrigger] = useState(0);
 
@@ -95,10 +112,6 @@ export const useSlashCommandProcessor = (
     prompt: React.ReactNode;
     onConfirm: (confirmed: boolean) => void;
   }>(null);
-  const [quitConfirmationRequest, setQuitConfirmationRequest] =
-    useState<null | {
-      onConfirm: (shouldQuit: boolean, action?: string) => void;
-    }>(null);
 
   const [sessionShellAllowlist, setSessionShellAllowlist] = useState(
     new Set<string>(),
@@ -110,16 +123,6 @@ export const useSlashCommandProcessor = (
     return new GitService(config.getProjectRoot(), config.storage);
   }, [config]);
 
-  const logger = useMemo(() => {
-    const l = new Logger(
-      config?.getSessionId() || '',
-      config?.storage ?? new Storage(process.cwd()),
-    );
-    // The logger's initialize is async, but we can create the instance
-    // synchronously. Commands that use it will await its initialization.
-    return l;
-  }, [config]);
-
   const [pendingItem, setPendingItem] = useState<HistoryItemWithoutId | null>(
     null,
   );
@@ -164,11 +167,6 @@ export const useSlashCommandProcessor = (
           type: 'quit',
           duration: message.duration,
         };
-      } else if (message.type === MessageType.QUIT_CONFIRMATION) {
-        historyItemContent = {
-          type: 'quit_confirmation',
-          duration: message.duration,
-        };
       } else if (message.type === MessageType.COMPRESSION) {
         historyItemContent = {
           type: 'compression',
@@ -218,8 +216,9 @@ export const useSlashCommandProcessor = (
           actions.addConfirmUpdateExtensionRequest,
       },
       session: {
-        stats: session.stats,
+        stats: sessionStats,
         sessionShellAllowlist,
+        startNewSession,
       },
     }),
     [
@@ -231,7 +230,8 @@ export const useSlashCommandProcessor = (
       addItem,
       clearItems,
       refreshStatic,
-      session.stats,
+      sessionStats,
+      startNewSession,
       actions,
       pendingItem,
       setPendingItem,
@@ -302,10 +302,25 @@ export const useSlashCommandProcessor = (
         return false;
       }
 
+      const recordedItems: Array<Omit<HistoryItem, 'id'>> = [];
+      const recordItem = (item: Omit<HistoryItem, 'id'>) => {
+        recordedItems.push(item);
+      };
+      const addItemWithRecording: UseHistoryManagerReturn['addItem'] = (
+        item,
+        timestamp,
+      ) => {
+        recordItem(item);
+        return addItem(item, timestamp);
+      };
+
       setIsProcessing(true);
 
       const userMessageTimestamp = Date.now();
-      addItem({ type: MessageType.USER, text: trimmed }, userMessageTimestamp);
+      addItemWithRecording(
+        { type: MessageType.USER, text: trimmed },
+        userMessageTimestamp,
+      );
 
       let hasError = false;
       const {
@@ -324,6 +339,10 @@ export const useSlashCommandProcessor = (
           if (commandToExecute.action) {
             const fullCommandContext: CommandContext = {
               ...commandContext,
+              ui: {
+                ...commandContext.ui,
+                addItem: addItemWithRecording,
+              },
               invocation: {
                 raw: trimmed,
                 name: commandToExecute.name,
@@ -418,74 +437,6 @@ export const useSlashCommandProcessor = (
                   });
                   return { type: 'handled' };
                 }
-                case 'quit_confirmation':
-                  // Show quit confirmation dialog instead of immediately quitting
-                  setQuitConfirmationRequest({
-                    onConfirm: (shouldQuit: boolean, action?: string) => {
-                      setQuitConfirmationRequest(null);
-                      if (!shouldQuit) {
-                        // User cancelled the quit operation - do nothing
-                        return;
-                      }
-                      if (shouldQuit) {
-                        if (action === 'save_and_quit') {
-                          // First save conversation with auto-generated tag, then quit
-                          const timestamp = new Date()
-                            .toISOString()
-                            .replace(/[:.]/g, '-');
-                          const autoSaveTag = `auto-save chat ${timestamp}`;
-                          handleSlashCommand(`/chat save "${autoSaveTag}"`);
-                          setTimeout(() => handleSlashCommand('/quit'), 100);
-                        } else if (action === 'summary_and_quit') {
-                          // Generate summary and then quit
-                          handleSlashCommand('/summary')
-                            .then(() => {
-                              // Wait for user to see the summary result
-                              setTimeout(() => {
-                                handleSlashCommand('/quit');
-                              }, 1200);
-                            })
-                            .catch((error) => {
-                              // If summary fails, still quit but show error
-                              addItem(
-                                {
-                                  type: 'error',
-                                  text: `Failed to generate summary before quit: ${
-                                    error instanceof Error
-                                      ? error.message
-                                      : String(error)
-                                  }`,
-                                },
-                                Date.now(),
-                              );
-                              // Give user time to see the error message
-                              setTimeout(() => {
-                                handleSlashCommand('/quit');
-                              }, 1000);
-                            });
-                        } else {
-                          // Just quit immediately - trigger the actual quit action
-                          const now = Date.now();
-                          const { sessionStartTime } = session.stats;
-                          const wallDuration = now - sessionStartTime.getTime();
-
-                          actions.quit([
-                            {
-                              type: 'user',
-                              text: `/quit`,
-                              id: now - 1,
-                            },
-                            {
-                              type: 'quit',
-                              duration: formatDuration(wallDuration),
-                              id: now,
-                            },
-                          ]);
-                        }
-                      }
-                    },
-                  });
-                  return { type: 'handled' };
 
                 case 'quit':
                   actions.quit(result.messages);
@@ -550,7 +501,7 @@ export const useSlashCommandProcessor = (
                   });
 
                   if (!confirmed) {
-                    addItem(
+                    addItemWithRecording(
                       {
                         type: MessageType.INFO,
                         text: 'Operation cancelled.',
@@ -606,7 +557,7 @@ export const useSlashCommandProcessor = (
           });
           logSlashCommand(config, event);
         }
-        addItem(
+        addItemWithRecording(
           {
             type: MessageType.ERROR,
             text: e instanceof Error ? e.message : String(e),
@@ -615,6 +566,38 @@ export const useSlashCommandProcessor = (
         );
         return { type: 'handled' };
       } finally {
+        if (config?.getChatRecordingService) {
+          const chatRecorder = config.getChatRecordingService();
+          const primaryCommand =
+            resolvedCommandPath[0] ||
+            trimmed.replace(/^[/?]/, '').split(/\s+/)[0] ||
+            trimmed;
+          const shouldRecord =
+            !SLASH_COMMANDS_SKIP_RECORDING.has(primaryCommand);
+          try {
+            if (shouldRecord) {
+              chatRecorder?.recordSlashCommand({
+                phase: 'invocation',
+                rawCommand: trimmed,
+              });
+              const outputItems = recordedItems
+                .filter((item) => item.type !== 'user')
+                .map(serializeHistoryItemForRecording);
+              chatRecorder?.recordSlashCommand({
+                phase: 'result',
+                rawCommand: trimmed,
+                outputHistoryItems: outputItems,
+              });
+            }
+          } catch (recordError) {
+            if (config.getDebugMode()) {
+              console.error(
+                '[slashCommand] Failed to record slash command:',
+                recordError,
+              );
+            }
+          }
+        }
         if (config && resolvedCommandPath[0] && !hasError) {
           const event = makeSlashCommandEvent({
             command: resolvedCommandPath[0],
@@ -637,7 +620,6 @@ export const useSlashCommandProcessor = (
       setSessionShellAllowlist,
       setIsProcessing,
       setConfirmationRequest,
-      session.stats,
     ],
   );
 
@@ -648,6 +630,5 @@ export const useSlashCommandProcessor = (
     commandContext,
     shellConfirmationRequest,
     confirmationRequest,
-    quitConfirmationRequest,
   };
 };

packages/cli/src/ui/hooks/useDialogClose.ts

@@ -44,11 +44,6 @@ export interface DialogCloseOptions {
   // Welcome back dialog
   showWelcomeBackDialog: boolean;
   handleWelcomeBackClose: () => void;
-
-  // Quit confirmation dialog
-  quitConfirmationRequest: {
-    onConfirm: (shouldQuit: boolean, action?: string) => void;
-  } | null;
 }
 
 /**
@@ -96,9 +91,6 @@ export function useDialogClose(options: DialogCloseOptions) {
       return true;
     }
 
-    // Note: quitConfirmationRequest is NOT handled here anymore
-    // It's handled specially in handleExit - ctrl+c in quit-confirm should exit immediately
-
     // No dialog was open
     return false;
   }, [options]);

packages/cli/src/ui/hooks/useGeminiStream.test.tsx

@@ -152,6 +152,9 @@ vi.mock('../contexts/SessionContext.js', () => ({
     startNewPrompt: mockStartNewPrompt,
     addUsage: mockAddUsage,
     getPromptCount: vi.fn(() => 5),
+    stats: {
+      sessionId: 'test-session-id',
+    },
   })),
 }));
 
@@ -514,6 +517,7 @@ describe('useGeminiStream', () => {
       expectedMergedResponse,
       expect.any(AbortSignal),
       'prompt-id-2',
+      { isContinuation: true },
     );
   });
 
@@ -840,6 +844,7 @@ describe('useGeminiStream', () => {
         toolCallResponseParts,
         expect.any(AbortSignal),
         'prompt-id-4',
+        { isContinuation: true },
       );
     });
 
@@ -1165,6 +1170,7 @@ describe('useGeminiStream', () => {
           'This is the actual prompt from the command file.',
           expect.any(AbortSignal),
           expect.any(String),
+          undefined,
         );
 
         expect(mockScheduleToolCalls).not.toHaveBeenCalled();
@@ -1191,6 +1197,7 @@ describe('useGeminiStream', () => {
           '',
           expect.any(AbortSignal),
           expect.any(String),
+          undefined,
         );
       });
     });
@@ -1209,6 +1216,7 @@ describe('useGeminiStream', () => {
           '// This is a line comment',
           expect.any(AbortSignal),
           expect.any(String),
+          undefined,
         );
       });
     });
@@ -1227,6 +1235,7 @@ describe('useGeminiStream', () => {
           '/* This is a block comment */',
           expect.any(AbortSignal),
           expect.any(String),
+          undefined,
         );
       });
     });
@@ -2151,6 +2160,7 @@ describe('useGeminiStream', () => {
       processedQueryParts, // Argument 1: The parts array directly
       expect.any(AbortSignal), // Argument 2: An AbortSignal
       expect.any(String), // Argument 3: The prompt_id string
+      undefined, // Argument 4: Options (undefined for normal prompts)
     );
   });
 
@@ -2251,6 +2261,57 @@ describe('useGeminiStream', () => {
       });
     });
 
+    it('should accumulate streamed thought descriptions', async () => {
+      mockSendMessageStream.mockReturnValue(
+        (async function* () {
+          yield {
+            type: ServerGeminiEventType.Thought,
+            value: { subject: '', description: 'thinking ' },
+          };
+          yield {
+            type: ServerGeminiEventType.Thought,
+            value: { subject: '', description: 'more' },
+          };
+          yield {
+            type: ServerGeminiEventType.Finished,
+            value: { reason: 'STOP', usageMetadata: undefined },
+          };
+        })(),
+      );
+
+      const { result } = renderHook(() =>
+        useGeminiStream(
+          new MockedGeminiClientClass(mockConfig),
+          [],
+          mockAddItem,
+          mockConfig,
+          mockLoadedSettings,
+          mockOnDebugMessage,
+          mockHandleSlashCommand,
+          false,
+          () => 'vscode' as EditorType,
+          () => {},
+          () => Promise.resolve(),
+          false,
+          () => {},
+          () => {},
+          () => {},
+          false, // visionModelPreviewEnabled
+          () => {},
+          80,
+          24,
+        ),
+      );
+
+      await act(async () => {
+        await result.current.submitQuery('Streamed thought');
+      });
+
+      await waitFor(() => {
+        expect(result.current.thought?.description).toBe('thinking more');
+      });
+    });
+
     it('should memoize pendingHistoryItems', () => {
       mockUseReactToolScheduler.mockReturnValue([
         [],
@@ -2509,6 +2570,7 @@ describe('useGeminiStream', () => {
         'First query',
         expect.any(AbortSignal),
         expect.any(String),
+        undefined,
       );
 
       // Verify only the first query was added to history
@@ -2560,12 +2622,14 @@ describe('useGeminiStream', () => {
         'First query',
         expect.any(AbortSignal),
         expect.any(String),
+        undefined,
       );
       expect(mockSendMessageStream).toHaveBeenNthCalledWith(
         2,
         'Second query',
         expect.any(AbortSignal),
         expect.any(String),
+        undefined,
       );
     });
 
@@ -2588,6 +2652,7 @@ describe('useGeminiStream', () => {
         'Second query',
         expect.any(AbortSignal),
         expect.any(String),
+        undefined,
       );
     });
   });