feat: add export command draft for session history with markdown and HTML formats

fix: docs

README.md

@@ -201,6 +201,11 @@ If you encounter issues, check the [troubleshooting guide](https://qwenlm.github
 
 To report a bug from within the CLI, run `/bug` and include a short title and repro steps.
 
+## Connect with Us
+
+- Discord: https://discord.gg/ycKBjdNd
+- Dingtalk: https://qr.dingtalk.com/action/joingroup?code=v1,k1,+FX6Gf/ZDlTahTIRi8AEQhIaBlqykA0j+eBKKdhLeAE=&_dt_no_comment=1&origin=1
+
 ## Acknowledgments
 
 This project is based on [Google Gemini CLI](https://github.com/google-gemini/gemini-cli). We acknowledge and appreciate the excellent work of the Gemini CLI team. Our main contribution focuses on parser-level adaptations to better support Qwen-Coder models.

docs/users/configuration/settings.md

@@ -480,7 +480,7 @@ Arguments passed directly when running the CLI can override other configurations
 | `--telemetry-otlp-protocol`  |       | Sets the OTLP protocol for telemetry (`grpc` or `http`).                                                                                                                                |                                        | Defaults to `grpc`. See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `--telemetry-log-prompts`    |       | Enables logging of prompts for telemetry.                                                                                                                                               |                                        | See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `--checkpointing`            |       | Enables [checkpointing](../features/checkpointing).                                                                                                                                     |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `--acp`                      |       | Enables ACP mode (Agent Control Protocol). Useful for IDE/editor integrations like [Zed](../integration-zed).                                                                           |                                        | Stable. Replaces the deprecated `--experimental-acp` flag.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `--acp`                      |       | Enables ACP mode (Agent Client Protocol). Useful for IDE/editor integrations like [Zed](../integration-zed).                                                                            |                                        | Stable. Replaces the deprecated `--experimental-acp` flag.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `--experimental-skills`      |       | Enables experimental [Agent Skills](../features/skills) (registers the `skill` tool and loads Skills from `.qwen/skills/` and `~/.qwen/skills/`).                                       |                                        | Experimental.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `--extensions`               | `-e`  | Specifies a list of extensions to use for the session.                                                                                                                                  | Extension names                        | If not provided, all available extensions are used. Use the special term `qwen -e none` to disable all extensions. Example: `qwen -e my-extension -e my-other-extension`                                                                                                                                                                                                                                                                                                                                                                                        |
 | `--list-extensions`          | `-l`  | Lists all available extensions and exits.                                                                                                                                               |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

docs/users/integration-jetbrains.md

@@ -1,11 +1,11 @@
 # JetBrains IDEs
 
-> JetBrains IDEs provide native support for AI coding assistants through the Agent Control Protocol (ACP). This integration allows you to use Qwen Code directly within your JetBrains IDE with real-time code suggestions.
+> JetBrains IDEs provide native support for AI coding assistants through the Agent Client Protocol (ACP). This integration allows you to use Qwen Code directly within your JetBrains IDE with real-time code suggestions.
 
 ### Features
 
 - **Native agent experience**: Integrated AI assistant panel within your JetBrains IDE
-- **Agent Control Protocol**: Full support for ACP enabling advanced IDE interactions
+- **Agent Client Protocol**: Full support for ACP enabling advanced IDE interactions
 - **Symbol management**: #-mention files to add them to the conversation context
 - **Conversation history**: Access to past conversations within the IDE
 
@@ -40,7 +40,7 @@
 
 4. The Qwen Code agent should now be available in the AI Assistant panel
 
-![Qwen Code in JetBrains AI Chat](./images/jetbrains-acp.png)
+![Qwen Code in JetBrains AI Chat](https://img.alicdn.com/imgextra/i3/O1CN01ZxYel21y433Ci6eg0_!!6000000006524-2-tps-2774-1494.png)
 
 ## Troubleshooting
 

docs/users/integration-vscode.md

@@ -22,13 +22,7 @@
 
 ### Installation
 
-1. Install Qwen Code CLI:
-
-   ```bash
-   npm install -g qwen-code
-   ```
-
-2. Download and install the extension from the [Visual Studio Code Extension Marketplace](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion).
+Download and install the extension from the [Visual Studio Code Extension Marketplace](https://marketplace.visualstudio.com/items?itemName=qwenlm.qwen-code-vscode-ide-companion).
 
 ## Troubleshooting
 

docs/users/integration-zed.md

@@ -1,6 +1,6 @@
 # Zed Editor
 
-> Zed Editor provides native support for AI coding assistants through the Agent Control Protocol (ACP). This integration allows you to use Qwen Code directly within Zed's interface with real-time code suggestions.
+> Zed Editor provides native support for AI coding assistants through the Agent Client Protocol (ACP). This integration allows you to use Qwen Code directly within Zed's interface with real-time code suggestions.
 
 ![Zed Editor Overview](https://img.alicdn.com/imgextra/i1/O1CN01aAhU311GwEoNh27FP_!!6000000000686-2-tps-3024-1898.png)
 
@@ -20,9 +20,9 @@
 
 1. Install Qwen Code CLI:
 
-   ```bash
-   npm install -g qwen-code
-   ```
+```bash
+npm install -g @qwen-code/qwen-code
+```
 
 2. Download and install [Zed Editor](https://zed.dev/)
 

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

@@ -831,7 +831,7 @@ describe('Permission Control (E2E)', () => {
         TEST_TIMEOUT,
       );
 
-      it(
+      it.skip(
         'should execute dangerous commands without confirmation',
         async () => {
           const q = query({

package-lock.json

@@ -18588,7 +18588,7 @@
     },
     "packages/sdk-typescript": {
       "name": "@qwen-code/sdk",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "license": "Apache-2.0",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.25.1",

packages/cli/src/services/BuiltinCommandLoader.ts

@@ -18,6 +18,7 @@ import { copyCommand } from '../ui/commands/copyCommand.js';
 import { docsCommand } from '../ui/commands/docsCommand.js';
 import { directoryCommand } from '../ui/commands/directoryCommand.js';
 import { editorCommand } from '../ui/commands/editorCommand.js';
+import { exportCommand } from '../ui/commands/exportCommand.js';
 import { extensionsCommand } from '../ui/commands/extensionsCommand.js';
 import { helpCommand } from '../ui/commands/helpCommand.js';
 import { ideCommand } from '../ui/commands/ideCommand.js';
@@ -67,6 +68,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       docsCommand,
       directoryCommand,
       editorCommand,
+      exportCommand,
       extensionsCommand,
       helpCommand,
       await ideCommand(),

packages/cli/src/ui/auth/useAuth.ts

@@ -83,12 +83,26 @@ export const useAuthCommand = (
     async (authType: AuthType, credentials?: OpenAICredentials) => {
       try {
         const authTypeScope = getPersistScopeForModelSelection(settings);
+
+        // Persist authType
         settings.setValue(
           authTypeScope,
           'security.auth.selectedType',
           authType,
         );
 
+        // Persist model from ContentGenerator config (handles fallback cases)
+        // This ensures that when syncAfterAuthRefresh falls back to default model,
+        // it gets persisted to settings.json
+        const contentGeneratorConfig = config.getContentGeneratorConfig();
+        if (contentGeneratorConfig?.model) {
+          settings.setValue(
+            authTypeScope,
+            'model.name',
+            contentGeneratorConfig.model,
+          );
+        }
+
         // Only update credentials if not switching to QWEN_OAUTH,
         // so that OpenAI credentials are preserved when switching to QWEN_OAUTH.
         if (authType !== AuthType.QWEN_OAUTH && credentials) {
@@ -106,9 +120,6 @@ export const useAuthCommand = (
               credentials.baseUrl,
             );
           }
-          if (credentials?.model != null) {
-            settings.setValue(authTypeScope, 'model.name', credentials.model);
-          }
         }
       } catch (error) {
         handleAuthFailure(error);

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

@@ -0,0 +1,379 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import { exportCommand } from './exportCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+import type { Part, Content } from '@google/genai';
+import {
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from '../utils/exportUtils.js';
+
+const mockSessionServiceMocks = vi.hoisted(() => ({
+  loadLastSession: vi.fn(),
+}));
+
+vi.mock('@qwen-code/qwen-code-core', () => {
+  class SessionService {
+    constructor(_cwd: string) {}
+    async loadLastSession() {
+      return mockSessionServiceMocks.loadLastSession();
+    }
+  }
+
+  return {
+    SessionService,
+  };
+});
+
+vi.mock('../utils/exportUtils.js', () => ({
+  transformToMarkdown: vi.fn(),
+  loadHtmlTemplate: vi.fn(),
+  prepareExportData: vi.fn(),
+  injectDataIntoHtmlTemplate: vi.fn(),
+  generateExportFilename: vi.fn(),
+}));
+
+vi.mock('node:fs/promises', () => ({
+  writeFile: vi.fn(),
+}));
+
+describe('exportCommand', () => {
+  const mockSessionData = {
+    conversation: {
+      sessionId: 'test-session-id',
+      startTime: '2025-01-01T00:00:00Z',
+      messages: [
+        {
+          type: 'user',
+          message: {
+            parts: [{ text: 'Hello' }] as Part[],
+          } as Content,
+        },
+      ] as ChatRecord[],
+    },
+  };
+
+  let mockContext: ReturnType<typeof createMockCommandContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockSessionServiceMocks.loadLastSession.mockResolvedValue(mockSessionData);
+
+    mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getWorkingDir: vi.fn().mockReturnValue('/test/dir'),
+          getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+        },
+      },
+    });
+
+    vi.mocked(transformToMarkdown).mockReturnValue('# Test Markdown');
+    vi.mocked(loadHtmlTemplate).mockResolvedValue(
+      '<html><script id="chat-data" type="application/json">// DATA_PLACEHOLDER</script></html>',
+    );
+    vi.mocked(prepareExportData).mockReturnValue({
+      sessionId: 'test-session-id',
+      startTime: '2025-01-01T00:00:00Z',
+      messages: mockSessionData.conversation.messages,
+    });
+    vi.mocked(injectDataIntoHtmlTemplate).mockReturnValue(
+      '<html><script id="chat-data" type="application/json">{"data": "test"}</script></html>',
+    );
+    vi.mocked(generateExportFilename).mockImplementation(
+      (ext: string) => `export-2025-01-01T00-00-00-000Z.${ext}`,
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('command structure', () => {
+    it('should have correct name and description', () => {
+      expect(exportCommand.name).toBe('export');
+      expect(exportCommand.description).toBe(
+        'Export current session message history to a file',
+      );
+    });
+
+    it('should have md and html subcommands', () => {
+      expect(exportCommand.subCommands).toHaveLength(2);
+      expect(exportCommand.subCommands?.map((c) => c.name)).toEqual([
+        'md',
+        'html',
+      ]);
+    });
+  });
+
+  describe('exportMarkdownAction', () => {
+    it('should export session to markdown file', async () => {
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('export-2025-01-01T00-00-00-000Z.md'),
+      });
+
+      expect(mockSessionServiceMocks.loadLastSession).toHaveBeenCalled();
+      expect(transformToMarkdown).toHaveBeenCalledWith(
+        mockSessionData.conversation.messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+      expect(generateExportFilename).toHaveBeenCalledWith('md');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('export-2025-01-01T00-00-00-000Z.md'),
+        '# Test Markdown',
+        'utf-8',
+      );
+    });
+
+    it('should return error when config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      });
+    });
+
+    it('should return error when working directory cannot be determined', async () => {
+      const contextWithoutCwd = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue(null),
+          },
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand || !mdCommand.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(contextWithoutCwd, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not determine current working directory.',
+      });
+    });
+
+    it('should return error when no session is found', async () => {
+      mockSessionServiceMocks.loadLastSession.mockResolvedValue(undefined);
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      });
+    });
+
+    it('should handle errors during export', async () => {
+      const error = new Error('File write failed');
+      vi.mocked(fs.writeFile).mockRejectedValue(error);
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      const result = await mdCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: File write failed',
+      });
+    });
+
+    it('should use project root when working dir is not available', async () => {
+      const contextWithProjectRoot = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue('/test/project'),
+          },
+        },
+      });
+
+      const mdCommand = exportCommand.subCommands?.find((c) => c.name === 'md');
+      if (!mdCommand?.action) {
+        throw new Error('md command not found');
+      }
+      await mdCommand.action(contextWithProjectRoot, '');
+    });
+  });
+
+  describe('exportHtmlAction', () => {
+    it('should export session to HTML file', async () => {
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining(
+          'export-2025-01-01T00-00-00-000Z.html',
+        ),
+      });
+
+      expect(mockSessionServiceMocks.loadLastSession).toHaveBeenCalled();
+      expect(loadHtmlTemplate).toHaveBeenCalled();
+      expect(prepareExportData).toHaveBeenCalledWith(
+        mockSessionData.conversation,
+      );
+      expect(injectDataIntoHtmlTemplate).toHaveBeenCalled();
+      expect(generateExportFilename).toHaveBeenCalledWith('html');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('export-2025-01-01T00-00-00-000Z.html'),
+        expect.stringContaining('{"data": "test"}'),
+        'utf-8',
+      );
+    });
+
+    it('should return error when config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      });
+    });
+
+    it('should return error when working directory cannot be determined', async () => {
+      const contextWithoutCwd = createMockCommandContext({
+        services: {
+          config: {
+            getWorkingDir: vi.fn().mockReturnValue(null),
+            getProjectRoot: vi.fn().mockReturnValue(null),
+          },
+        },
+      });
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand || !htmlCommand.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(contextWithoutCwd, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not determine current working directory.',
+      });
+    });
+
+    it('should return error when no session is found', async () => {
+      mockSessionServiceMocks.loadLastSession.mockResolvedValue(undefined);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      });
+    });
+
+    it('should handle errors during HTML template loading', async () => {
+      const error = new Error('Failed to fetch template');
+      vi.mocked(loadHtmlTemplate).mockRejectedValue(error);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: Failed to fetch template',
+      });
+    });
+
+    it('should handle errors during file write', async () => {
+      const error = new Error('File write failed');
+      vi.mocked(fs.writeFile).mockRejectedValue(error);
+
+      const htmlCommand = exportCommand.subCommands?.find(
+        (c) => c.name === 'html',
+      );
+      if (!htmlCommand?.action) {
+        throw new Error('html command not found');
+      }
+      const result = await htmlCommand.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Failed to export session: File write failed',
+      });
+    });
+  });
+});

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

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type MessageActionReturn,
+  CommandKind,
+} from './types.js';
+import { SessionService } from '@qwen-code/qwen-code-core';
+import {
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from '../utils/exportUtils.js';
+
+/**
+ * Action for the 'md' subcommand - exports session to markdown.
+ */
+async function exportMarkdownAction(
+  context: CommandContext,
+): Promise<MessageActionReturn> {
+  const { services } = context;
+  const { config } = services;
+
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    };
+  }
+
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not determine current working directory.',
+    };
+  }
+
+  try {
+    // Load the current session
+    const sessionService = new SessionService(cwd);
+    const sessionData = await sessionService.loadLastSession();
+
+    if (!sessionData) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      };
+    }
+
+    const { conversation } = sessionData;
+
+    const markdown = transformToMarkdown(
+      conversation.messages,
+      conversation.sessionId,
+      conversation.startTime,
+    );
+
+    const filename = generateExportFilename('md');
+    const filepath = path.join(cwd, filename);
+
+    // Write to file
+    await fs.writeFile(filepath, markdown, 'utf-8');
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Session exported to markdown: ${filename}`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to export session: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Action for the 'html' subcommand - exports session to HTML.
+ */
+async function exportHtmlAction(
+  context: CommandContext,
+): Promise<MessageActionReturn> {
+  const { services } = context;
+  const { config } = services;
+
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    };
+  }
+
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not determine current working directory.',
+    };
+  }
+
+  try {
+    // Load the current session
+    const sessionService = new SessionService(cwd);
+    const sessionData = await sessionService.loadLastSession();
+
+    if (!sessionData) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      };
+    }
+
+    const { conversation } = sessionData;
+
+    const template = await loadHtmlTemplate();
+    const exportData = prepareExportData(conversation);
+    const html = injectDataIntoHtmlTemplate(template, exportData);
+
+    const filename = generateExportFilename('html');
+    const filepath = path.join(cwd, filename);
+
+    // Write to file
+    await fs.writeFile(filepath, html, 'utf-8');
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Session exported to HTML: ${filename}`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to export session: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Main export command with subcommands.
+ */
+export const exportCommand: SlashCommand = {
+  name: 'export',
+  description: 'Export current session message history to a file',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    {
+      name: 'md',
+      description: 'Export session to markdown format',
+      kind: CommandKind.BUILT_IN,
+      action: exportMarkdownAction,
+    },
+    {
+      name: 'html',
+      description: 'Export session to HTML format',
+      kind: CommandKind.BUILT_IN,
+      action: exportHtmlAction,
+    },
+  ],
+};

packages/cli/src/ui/utils/exportUtils.test.ts

@@ -0,0 +1,404 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  extractTextFromContent,
+  transformToMarkdown,
+  loadHtmlTemplate,
+  prepareExportData,
+  injectDataIntoHtmlTemplate,
+  generateExportFilename,
+} from './exportUtils.js';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+import type { Part, Content } from '@google/genai';
+
+describe('exportUtils', () => {
+  describe('extractTextFromContent', () => {
+    it('should return empty string for undefined content', () => {
+      expect(extractTextFromContent(undefined)).toBe('');
+    });
+
+    it('should return empty string for content without parts', () => {
+      expect(extractTextFromContent({} as Content)).toBe('');
+    });
+
+    it('should extract text from text parts', () => {
+      const content: Content = {
+        parts: [{ text: 'Hello' }, { text: 'World' }] as Part[],
+      };
+      expect(extractTextFromContent(content)).toBe('Hello\nWorld');
+    });
+
+    it('should format function call parts', () => {
+      const content: Content = {
+        parts: [
+          {
+            functionCall: {
+              name: 'testFunction',
+              args: { param1: 'value1' },
+            },
+          },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('[Function Call: testFunction]');
+      expect(result).toContain('"param1": "value1"');
+    });
+
+    it('should format function response parts', () => {
+      const content: Content = {
+        parts: [
+          {
+            functionResponse: {
+              name: 'testFunction',
+              response: { result: 'success' },
+            },
+          },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('[Function Response: testFunction]');
+      expect(result).toContain('"result": "success"');
+    });
+
+    it('should handle mixed part types', () => {
+      const content: Content = {
+        parts: [
+          { text: 'Start' },
+          {
+            functionCall: {
+              name: 'call',
+              args: {},
+            },
+          },
+          { text: 'End' },
+        ] as Part[],
+      };
+      const result = extractTextFromContent(content);
+      expect(result).toContain('Start');
+      expect(result).toContain('[Function Call: call]');
+      expect(result).toContain('End');
+    });
+  });
+
+  describe('transformToMarkdown', () => {
+    const mockMessages: ChatRecord[] = [
+      {
+        uuid: 'uuid-1',
+        parentUuid: null,
+        sessionId: 'test-session-id',
+        timestamp: '2025-01-01T00:00:00Z',
+        type: 'user',
+        cwd: '/test',
+        version: '1.0.0',
+        message: {
+          parts: [{ text: 'Hello, how are you?' }] as Part[],
+        } as Content,
+      },
+      {
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+        sessionId: 'test-session-id',
+        timestamp: '2025-01-01T00:00:01Z',
+        type: 'assistant',
+        cwd: '/test',
+        version: '1.0.0',
+        message: {
+          parts: [{ text: 'I am doing well, thank you!' }] as Part[],
+        } as Content,
+      },
+    ];
+
+    it('should transform messages to markdown format', () => {
+      const result = transformToMarkdown(
+        mockMessages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('# Chat Session Export');
+      expect(result).toContain('**Session ID**: test-session-id');
+      expect(result).toContain('**Start Time**: 2025-01-01T00:00:00Z');
+      expect(result).toContain('## User');
+      expect(result).toContain('Hello, how are you?');
+      expect(result).toContain('## Assistant');
+      expect(result).toContain('I am doing well, thank you!');
+    });
+
+    it('should include exported timestamp', () => {
+      const before = new Date().toISOString();
+      const result = transformToMarkdown(
+        mockMessages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+      const after = new Date().toISOString();
+
+      expect(result).toContain('**Exported**:');
+      const exportedMatch = result.match(/\*\*Exported\*\*: (.+)/);
+      expect(exportedMatch).toBeTruthy();
+      if (exportedMatch) {
+        const exportedTime = exportedMatch[1].trim();
+        expect(exportedTime >= before).toBe(true);
+        expect(exportedTime <= after).toBe(true);
+      }
+    });
+
+    it('should format tool_result messages', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-3',
+          parentUuid: 'uuid-2',
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:02Z',
+          type: 'tool_result',
+          cwd: '/test',
+          version: '1.0.0',
+          toolCallResult: {
+            resultDisplay: 'Tool output',
+          },
+          message: {
+            parts: [{ text: 'Additional info' }] as Part[],
+          } as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('## Tool Result');
+      expect(result).toContain('```');
+      expect(result).toContain('Tool output');
+      expect(result).toContain('Additional info');
+    });
+
+    it('should format tool_result with JSON resultDisplay', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-4',
+          parentUuid: 'uuid-3',
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:03Z',
+          type: 'tool_result',
+          cwd: '/test',
+          version: '1.0.0',
+          toolCallResult: {
+            resultDisplay: '{"key": "value"}',
+          },
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('## Tool Result');
+      expect(result).toContain('```');
+      expect(result).toContain('"key": "value"');
+    });
+
+    it('should handle chat compression system messages', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-5',
+          parentUuid: null,
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:04Z',
+          type: 'system',
+          subtype: 'chat_compression',
+          cwd: '/test',
+          version: '1.0.0',
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).toContain('_[Chat history compressed]_');
+    });
+
+    it('should skip system messages without subtype', () => {
+      const messages: ChatRecord[] = [
+        {
+          uuid: 'uuid-6',
+          parentUuid: null,
+          sessionId: 'test-session-id',
+          timestamp: '2025-01-01T00:00:05Z',
+          type: 'system',
+          cwd: '/test',
+          version: '1.0.0',
+          message: {} as Content,
+        },
+      ];
+
+      const result = transformToMarkdown(
+        messages,
+        'test-session-id',
+        '2025-01-01T00:00:00Z',
+      );
+
+      expect(result).not.toContain('## System');
+    });
+  });
+
+  describe('loadHtmlTemplate', () => {
+    beforeEach(() => {
+      vi.stubGlobal('fetch', vi.fn());
+    });
+
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('should load HTML template from URL', async () => {
+      const mockTemplate = '<html><body>Test Template</body></html>';
+      const mockResponse = {
+        ok: true,
+        text: vi.fn().mockResolvedValue(mockTemplate),
+      };
+      vi.mocked(fetch).mockResolvedValue(mockResponse as unknown as Response);
+
+      const result = await loadHtmlTemplate();
+
+      expect(result).toBe(mockTemplate);
+      expect(fetch).toHaveBeenCalledWith(
+        'https://raw.githubusercontent.com/QwenLM/qwen-code/main/template_portable.html',
+      );
+    });
+
+    it('should throw error when fetch fails', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+      };
+      vi.mocked(fetch).mockResolvedValue(mockResponse as unknown as Response);
+
+      await expect(loadHtmlTemplate()).rejects.toThrow(
+        'Failed to fetch HTML template: 404 Not Found',
+      );
+    });
+
+    it('should throw error when network request fails', async () => {
+      const networkError = new Error('Network error');
+      vi.mocked(fetch).mockRejectedValue(networkError);
+
+      await expect(loadHtmlTemplate()).rejects.toThrow(
+        'Failed to load HTML template',
+      );
+      await expect(loadHtmlTemplate()).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('prepareExportData', () => {
+    it('should prepare export data from conversation', () => {
+      const conversation = {
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [
+          {
+            type: 'user',
+            message: {
+              parts: [{ text: 'Hello' }] as Part[],
+            } as Content,
+          },
+        ] as ChatRecord[],
+      };
+
+      const result = prepareExportData(conversation);
+
+      expect(result).toEqual({
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: conversation.messages,
+      });
+    });
+  });
+
+  describe('injectDataIntoHtmlTemplate', () => {
+    it('should inject JSON data into HTML template', () => {
+      const template = `
+        <html>
+          <body>
+            <script id="chat-data" type="application/json">
+              // DATA_PLACEHOLDER: Your JSONL data will be injected here
+            </script>
+          </body>
+        </html>
+      `;
+
+      const data = {
+        sessionId: 'test-session-id',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [] as ChatRecord[],
+      };
+
+      const result = injectDataIntoHtmlTemplate(template, data);
+
+      expect(result).toContain(
+        '<script id="chat-data" type="application/json">',
+      );
+      expect(result).toContain('"sessionId": "test-session-id"');
+      expect(result).toContain('"startTime": "2025-01-01T00:00:00Z"');
+      expect(result).not.toContain('DATA_PLACEHOLDER');
+    });
+
+    it('should handle template with whitespace around placeholder', () => {
+      const template = `<script id="chat-data" type="application/json">\n// DATA_PLACEHOLDER: Your JSONL data will be injected here\n</script>`;
+
+      const data = {
+        sessionId: 'test',
+        startTime: '2025-01-01T00:00:00Z',
+        messages: [] as ChatRecord[],
+      };
+
+      const result = injectDataIntoHtmlTemplate(template, data);
+
+      expect(result).toContain('"sessionId": "test"');
+      expect(result).not.toContain('DATA_PLACEHOLDER');
+    });
+  });
+
+  describe('generateExportFilename', () => {
+    it('should generate filename with timestamp and extension', () => {
+      const filename = generateExportFilename('md');
+
+      expect(filename).toMatch(
+        /^export-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.md$/,
+      );
+    });
+
+    it('should use provided extension', () => {
+      const filename1 = generateExportFilename('html');
+      const filename2 = generateExportFilename('json');
+
+      expect(filename1).toMatch(/\.html$/);
+      expect(filename2).toMatch(/\.json$/);
+    });
+
+    it('should replace colons and dots in timestamp', () => {
+      const filename = generateExportFilename('md');
+
+      expect(filename).not.toContain(':');
+      // The filename should contain a dot only for the extension
+      expect(filename.split('.').length).toBe(2);
+      // Check that timestamp part (before extension) doesn't contain dots
+      const timestampPart = filename.split('.')[0];
+      expect(timestampPart).not.toContain('.');
+    });
+  });
+});

packages/cli/src/ui/utils/exportUtils.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Part, Content } from '@google/genai';
+import type { ChatRecord } from '@qwen-code/qwen-code-core';
+
+const HTML_TEMPLATE_URL =
+  'https://raw.githubusercontent.com/QwenLM/qwen-code/main/template_portable.html';
+
+/**
+ * Extracts text content from a Content object's parts.
+ */
+export function extractTextFromContent(content: Content | undefined): string {
+  if (!content?.parts) return '';
+
+  const textParts: string[] = [];
+  for (const part of content.parts as Part[]) {
+    if ('text' in part) {
+      const textPart = part as { text: string };
+      textParts.push(textPart.text);
+    } else if ('functionCall' in part) {
+      const fnPart = part as { functionCall: { name: string; args: unknown } };
+      textParts.push(
+        `[Function Call: ${fnPart.functionCall.name}]\n${JSON.stringify(fnPart.functionCall.args, null, 2)}`,
+      );
+    } else if ('functionResponse' in part) {
+      const fnResPart = part as {
+        functionResponse: { name: string; response: unknown };
+      };
+      textParts.push(
+        `[Function Response: ${fnResPart.functionResponse.name}]\n${JSON.stringify(fnResPart.functionResponse.response, null, 2)}`,
+      );
+    }
+  }
+
+  return textParts.join('\n');
+}
+
+/**
+ * Transforms ChatRecord messages to markdown format.
+ */
+export function transformToMarkdown(
+  messages: ChatRecord[],
+  sessionId: string,
+  startTime: string,
+): string {
+  const lines: string[] = [];
+
+  // Add header with metadata
+  lines.push('# Chat Session Export\n');
+  lines.push(`**Session ID**: ${sessionId}\n`);
+  lines.push(`**Start Time**: ${startTime}\n`);
+  lines.push(`**Exported**: ${new Date().toISOString()}\n`);
+  lines.push('---\n');
+
+  // Process each message
+  for (const record of messages) {
+    if (record.type === 'user') {
+      lines.push('## User\n');
+      const text = extractTextFromContent(record.message);
+      lines.push(`${text}\n`);
+    } else if (record.type === 'assistant') {
+      lines.push('## Assistant\n');
+      const text = extractTextFromContent(record.message);
+      lines.push(`${text}\n`);
+    } else if (record.type === 'tool_result') {
+      lines.push('## Tool Result\n');
+      if (record.toolCallResult) {
+        const resultDisplay = record.toolCallResult.resultDisplay;
+        if (resultDisplay) {
+          lines.push('```\n');
+          lines.push(
+            typeof resultDisplay === 'string'
+              ? resultDisplay
+              : JSON.stringify(resultDisplay, null, 2),
+          );
+          lines.push('\n```\n');
+        }
+      }
+      const text = extractTextFromContent(record.message);
+      if (text) {
+        lines.push(`${text}\n`);
+      }
+    } else if (record.type === 'system') {
+      // Skip system messages or format them minimally
+      if (record.subtype === 'chat_compression') {
+        lines.push('_[Chat history compressed]_\n');
+      }
+    }
+
+    lines.push('\n');
+  }
+
+  return lines.join('');
+}
+
+/**
+ * Loads the HTML template from a remote URL via fetch.
+ * Throws an error if the fetch fails.
+ */
+export async function loadHtmlTemplate(): Promise<string> {
+  try {
+    const response = await fetch(HTML_TEMPLATE_URL);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch HTML template: ${response.status} ${response.statusText}`,
+      );
+    }
+    const template = await response.text();
+    return template;
+  } catch (error) {
+    throw new Error(
+      `Failed to load HTML template from ${HTML_TEMPLATE_URL}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+}
+
+/**
+ * Prepares export data from conversation.
+ */
+export function prepareExportData(conversation: {
+  sessionId: string;
+  startTime: string;
+  messages: ChatRecord[];
+}): {
+  sessionId: string;
+  startTime: string;
+  messages: ChatRecord[];
+} {
+  return {
+    sessionId: conversation.sessionId,
+    startTime: conversation.startTime,
+    messages: conversation.messages,
+  };
+}
+
+/**
+ * Injects JSON data into the HTML template.
+ */
+export function injectDataIntoHtmlTemplate(
+  template: string,
+  data: {
+    sessionId: string;
+    startTime: string;
+    messages: ChatRecord[];
+  },
+): string {
+  const jsonData = JSON.stringify(data, null, 2);
+  const html = template.replace(
+    /<script id="chat-data" type="application\/json">\s*\/\/ DATA_PLACEHOLDER:.*?\s*<\/script>/s,
+    `<script id="chat-data" type="application/json">\n${jsonData}\n    </script>`,
+  );
+  return html;
+}
+
+/**
+ * Generates a filename with timestamp for export files.
+ */
+export function generateExportFilename(extension: string): string {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return `export-${timestamp}.${extension}`;
+}

packages/cli/src/utils/commentJson.test.ts

@@ -8,10 +8,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import {
-  updateSettingsFilePreservingFormat,
-  applyUpdates,
-} from './commentJson.js';
+import { updateSettingsFilePreservingFormat } from './commentJson.js';
 
 describe('commentJson', () => {
   let tempDir: string;
@@ -183,18 +180,3 @@ describe('commentJson', () => {
     });
   });
 });
-
-describe('applyUpdates', () => {
-  it('should apply updates correctly', () => {
-    const original = { a: 1, b: { c: 2 } };
-    const updates = { b: { c: 3 } };
-    const result = applyUpdates(original, updates);
-    expect(result).toEqual({ a: 1, b: { c: 3 } });
-  });
-  it('should apply updates correctly when empty', () => {
-    const original = { a: 1, b: { c: 2 } };
-    const updates = { b: {} };
-    const result = applyUpdates(original, updates);
-    expect(result).toEqual({ a: 1, b: {} });
-  });
-});

packages/cli/src/utils/commentJson.ts

@@ -38,7 +38,7 @@ export function updateSettingsFilePreservingFormat(
   fs.writeFileSync(filePath, updatedContent, 'utf-8');
 }
 
-export function applyUpdates(
+function applyUpdates(
   current: Record<string, unknown>,
   updates: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -50,7 +50,6 @@ export function applyUpdates(
       typeof value === 'object' &&
       value !== null &&
       !Array.isArray(value) &&
-      Object.keys(value).length > 0 &&
       typeof result[key] === 'object' &&
       result[key] !== null &&
       !Array.isArray(result[key])

packages/cli/src/utils/modelConfigUtils.ts

@@ -120,7 +120,7 @@ export function resolveCliGenerationConfig(
 
   // Log warnings if any
   for (const warning of resolved.warnings) {
-    console.warn(`[modelProviderUtils] ${warning}`);
+    console.warn(warning);
   }
 
   // Resolve OpenAI logging config (CLI-specific, not part of core resolver)

packages/core/src/models/constants.ts

@@ -106,15 +106,6 @@ export const QWEN_OAUTH_MODELS: ModelConfig[] = [
     description:
       'The latest Qwen Coder model from Alibaba Cloud ModelStudio (version: qwen3-coder-plus-2025-09-23)',
     capabilities: { vision: false },
-    generationConfig: {
-      samplingParams: {
-        temperature: 0.7,
-        top_p: 0.9,
-        max_tokens: 8192,
-      },
-      timeout: 60000,
-      maxRetries: 3,
-    },
   },
   {
     id: 'vision-model',
@@ -122,14 +113,5 @@ export const QWEN_OAUTH_MODELS: ModelConfig[] = [
     description:
       'The latest Qwen Vision model from Alibaba Cloud ModelStudio (version: qwen3-vl-plus-2025-09-23)',
     capabilities: { vision: true },
-    generationConfig: {
-      samplingParams: {
-        temperature: 0.7,
-        top_p: 0.9,
-        max_tokens: 8192,
-      },
-      timeout: 60000,
-      maxRetries: 3,
-    },
   },
 ];

packages/core/src/models/modelsConfig.test.ts

@@ -480,6 +480,91 @@ describe('ModelsConfig', () => {
     expect(gc.apiKeyEnvKey).toBeUndefined();
   });
 
+  it('should use default model for new authType when switching from different authType with env vars', () => {
+    // Simulate cold start with OPENAI env vars (OPENAI_MODEL and OPENAI_API_KEY)
+    // This sets the model in generationConfig but no authType is selected yet
+    const modelsConfig = new ModelsConfig({
+      generationConfig: {
+        model: 'gpt-4o', // From OPENAI_MODEL env var
+        apiKey: 'openai-key-from-env',
+      },
+    });
+
+    // User switches to qwen-oauth via AuthDialog
+    // refreshAuth calls syncAfterAuthRefresh with the current model (gpt-4o)
+    // which doesn't exist in qwen-oauth registry, so it should use default
+    modelsConfig.syncAfterAuthRefresh(AuthType.QWEN_OAUTH, 'gpt-4o');
+
+    const gc = currentGenerationConfig(modelsConfig);
+    // Should use default qwen-oauth model (coder-model), not the OPENAI model
+    expect(gc.model).toBe('coder-model');
+    expect(gc.apiKey).toBe('QWEN_OAUTH_DYNAMIC_TOKEN');
+    expect(gc.apiKeyEnvKey).toBeUndefined();
+  });
+
+  it('should clear manual credentials when switching from USE_OPENAI to QWEN_OAUTH', () => {
+    // User manually set credentials for OpenAI
+    const modelsConfig = new ModelsConfig({
+      initialAuthType: AuthType.USE_OPENAI,
+      generationConfig: {
+        model: 'gpt-4o',
+        apiKey: 'manual-openai-key',
+        baseUrl: 'https://manual.example.com/v1',
+      },
+    });
+
+    // Manually set credentials via updateCredentials
+    modelsConfig.updateCredentials({
+      apiKey: 'manual-openai-key',
+      baseUrl: 'https://manual.example.com/v1',
+      model: 'gpt-4o',
+    });
+
+    // User switches to qwen-oauth
+    // Since authType is not USE_OPENAI, manual credentials should be cleared
+    // and default qwen-oauth model should be applied
+    modelsConfig.syncAfterAuthRefresh(AuthType.QWEN_OAUTH, 'gpt-4o');
+
+    const gc = currentGenerationConfig(modelsConfig);
+    // Should use default qwen-oauth model, not preserve manual OpenAI credentials
+    expect(gc.model).toBe('coder-model');
+    expect(gc.apiKey).toBe('QWEN_OAUTH_DYNAMIC_TOKEN');
+    // baseUrl should be set to qwen-oauth default, not preserved from manual OpenAI config
+    expect(gc.baseUrl).toBe('DYNAMIC_QWEN_OAUTH_BASE_URL');
+    expect(gc.apiKeyEnvKey).toBeUndefined();
+  });
+
+  it('should preserve manual credentials when switching to USE_OPENAI', () => {
+    // User manually set credentials
+    const modelsConfig = new ModelsConfig({
+      initialAuthType: AuthType.USE_OPENAI,
+      generationConfig: {
+        model: 'gpt-4o',
+        apiKey: 'manual-openai-key',
+        baseUrl: 'https://manual.example.com/v1',
+        samplingParams: { temperature: 0.9 },
+      },
+    });
+
+    // Manually set credentials via updateCredentials
+    modelsConfig.updateCredentials({
+      apiKey: 'manual-openai-key',
+      baseUrl: 'https://manual.example.com/v1',
+      model: 'gpt-4o',
+    });
+
+    // User switches to USE_OPENAI (same or different model)
+    // Since authType is USE_OPENAI, manual credentials should be preserved
+    modelsConfig.syncAfterAuthRefresh(AuthType.USE_OPENAI, 'gpt-4o');
+
+    const gc = currentGenerationConfig(modelsConfig);
+    // Should preserve manual credentials
+    expect(gc.model).toBe('gpt-4o');
+    expect(gc.apiKey).toBe('manual-openai-key');
+    expect(gc.baseUrl).toBe('https://manual.example.com/v1');
+    expect(gc.samplingParams?.temperature).toBe(0.9); // Preserved from initial config
+  });
+
   it('should maintain consistency between currentModelId and _generationConfig.model after initialization', () => {
     const modelProvidersConfig: ModelProvidersConfig = {
       openai: [

packages/core/src/models/modelsConfig.ts

@@ -600,7 +600,7 @@ export class ModelsConfig {
 
     // If credentials were manually set, don't apply modelProvider defaults
     // Just update the authType and preserve the manually set credentials
-    if (preserveManualCredentials) {
+    if (preserveManualCredentials && authType === AuthType.USE_OPENAI) {
       this.strictModelProviderSelection = false;
       this.currentAuthType = authType;
       if (modelId) {
@@ -621,7 +621,17 @@ export class ModelsConfig {
         this.applyResolvedModelDefaults(resolved);
       }
     } else {
+      // If the provided modelId doesn't exist in the registry for the new authType,
+      // use the default model for that authType instead of keeping the old model.
+      // This handles the case where switching from one authType (e.g., OPENAI with
+      // env vars) to another (e.g., qwen-oauth) - we should use the default model
+      // for the new authType, not the old model.
       this.currentAuthType = authType;
+      const defaultModel =
+        this.modelRegistry.getDefaultModelForAuthType(authType);
+      if (defaultModel) {
+        this.applyResolvedModelDefaults(defaultModel);
+      }
     }
   }
 

packages/core/src/qwen/qwenOAuth2.ts

@@ -559,6 +559,109 @@ export async function getQwenOAuthClient(
   }
 }
 
+/**
+ * Displays a formatted box with OAuth device authorization URL.
+ * Uses process.stderr.write() to bypass ConsolePatcher and ensure the auth URL
+ * is always visible to users, especially in non-interactive mode.
+ * Using stderr prevents corruption of structured JSON output (which goes to stdout)
+ * and follows the standard Unix convention of user-facing messages to stderr.
+ */
+function showFallbackMessage(verificationUriComplete: string): void {
+  const title = 'Qwen OAuth Device Authorization';
+  const url = verificationUriComplete;
+  const minWidth = 70;
+  const maxWidth = 80;
+  const boxWidth = Math.min(Math.max(title.length + 4, minWidth), maxWidth);
+
+  // Calculate the width needed for the box (account for padding)
+  const contentWidth = boxWidth - 4; // Subtract 2 spaces and 2 border chars
+
+  // Helper to wrap text to fit within box width
+  const wrapText = (text: string, width: number): string[] => {
+    // For URLs, break at any character if too long
+    if (text.startsWith('http://') || text.startsWith('https://')) {
+      const lines: string[] = [];
+      for (let i = 0; i < text.length; i += width) {
+        lines.push(text.substring(i, i + width));
+      }
+      return lines;
+    }
+
+    // For regular text, break at word boundaries
+    const words = text.split(' ');
+    const lines: string[] = [];
+    let currentLine = '';
+
+    for (const word of words) {
+      if (currentLine.length + word.length + 1 <= width) {
+        currentLine += (currentLine ? ' ' : '') + word;
+      } else {
+        if (currentLine) {
+          lines.push(currentLine);
+        }
+        currentLine = word.length > width ? word.substring(0, width) : word;
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    return lines;
+  };
+
+  // Build the box borders with title centered in top border
+  // Format: +--- Title ---+
+  const titleWithSpaces = ' ' + title + ' ';
+  const totalDashes = boxWidth - 2 - titleWithSpaces.length; // Subtract corners and title
+  const leftDashes = Math.floor(totalDashes / 2);
+  const rightDashes = totalDashes - leftDashes;
+  const topBorder =
+    '+' +
+    '-'.repeat(leftDashes) +
+    titleWithSpaces +
+    '-'.repeat(rightDashes) +
+    '+';
+  const emptyLine = '|' + ' '.repeat(boxWidth - 2) + '|';
+  const bottomBorder = '+' + '-'.repeat(boxWidth - 2) + '+';
+
+  // Build content lines
+  const instructionLines = wrapText(
+    'Please visit the following URL in your browser to authorize:',
+    contentWidth,
+  );
+  const urlLines = wrapText(url, contentWidth);
+  const waitingLine = 'Waiting for authorization to complete...';
+
+  // Write the box
+  process.stderr.write('\n' + topBorder + '\n');
+  process.stderr.write(emptyLine + '\n');
+
+  // Write instructions
+  for (const line of instructionLines) {
+    process.stderr.write(
+      '| ' + line + ' '.repeat(contentWidth - line.length) + ' |\n',
+    );
+  }
+
+  process.stderr.write(emptyLine + '\n');
+
+  // Write URL
+  for (const line of urlLines) {
+    process.stderr.write(
+      '| ' + line + ' '.repeat(contentWidth - line.length) + ' |\n',
+    );
+  }
+
+  process.stderr.write(emptyLine + '\n');
+
+  // Write waiting message
+  process.stderr.write(
+    '| ' + waitingLine + ' '.repeat(contentWidth - waitingLine.length) + ' |\n',
+  );
+
+  process.stderr.write(emptyLine + '\n');
+  process.stderr.write(bottomBorder + '\n\n');
+}
+
 async function authWithQwenDeviceFlow(
   client: QwenOAuth2Client,
   config: Config,
@@ -571,6 +674,50 @@ async function authWithQwenDeviceFlow(
   };
   qwenOAuth2Events.once(QwenOAuth2Event.AuthCancel, cancelHandler);
 
+  // Helper to check cancellation and return appropriate result
+  const checkCancellation = (): AuthResult | null => {
+    if (!isCancelled) {
+      return null;
+    }
+    const message = 'Authentication cancelled by user.';
+    console.debug('\n' + message);
+    qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
+    return { success: false, reason: 'cancelled', message };
+  };
+
+  // Helper to emit auth progress events
+  const emitAuthProgress = (
+    status: 'polling' | 'success' | 'error' | 'timeout' | 'rate_limit',
+    message: string,
+  ): void => {
+    qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, status, message);
+  };
+
+  // Helper to handle browser launch with error handling
+  const launchBrowser = async (url: string): Promise<void> => {
+    try {
+      const childProcess = await open(url);
+
+      // IMPORTANT: Attach an error handler to the returned child process.
+      // Without this, if `open` fails to spawn a process (e.g., `xdg-open` is not found
+      // in a minimal Docker container), it will emit an unhandled 'error' event,
+      // causing the entire Node.js process to crash.
+      if (childProcess) {
+        childProcess.on('error', (err) => {
+          console.debug(
+            'Browser launch failed:',
+            err.message || 'Unknown error',
+          );
+        });
+      }
+    } catch (err) {
+      console.debug(
+        'Failed to open browser:',
+        err instanceof Error ? err.message : 'Unknown error',
+      );
+    }
+  };
+
   try {
     // Generate PKCE code verifier and challenge
     const { code_verifier, code_challenge } = generatePKCEPair();
@@ -593,56 +740,18 @@ async function authWithQwenDeviceFlow(
     // Emit device authorization event for UI integration immediately
     qwenOAuth2Events.emit(QwenOAuth2Event.AuthUri, deviceAuth);
 
-    const showFallbackMessage = () => {
-      console.log('\n=== Qwen OAuth Device Authorization ===');
-      console.log(
-        'Please visit the following URL in your browser to authorize:',
-      );
-      console.log(`\n${deviceAuth.verification_uri_complete}\n`);
-      console.log('Waiting for authorization to complete...\n');
-    };
-
     // Always show the fallback message in non-interactive environments to ensure
     // users can see the authorization URL even if browser launching is attempted.
     // This is critical for headless/remote environments where browser launching
     // may silently fail without throwing an error.
-    if (config.isBrowserLaunchSuppressed()) {
-      // Browser launch is suppressed, show fallback message
-      showFallbackMessage();
-    } else {
-      // Try to open the URL in browser, but always show the URL as fallback
-      // to handle cases where browser launch silently fails (e.g., headless servers)
-      showFallbackMessage();
-      try {
-        const childProcess = await open(deviceAuth.verification_uri_complete);
+    showFallbackMessage(deviceAuth.verification_uri_complete);
 
-        // IMPORTANT: Attach an error handler to the returned child process.
-        // Without this, if `open` fails to spawn a process (e.g., `xdg-open` is not found
-        // in a minimal Docker container), it will emit an unhandled 'error' event,
-        // causing the entire Node.js process to crash.
-        if (childProcess) {
-          childProcess.on('error', (err) => {
-            console.debug(
-              'Browser launch failed:',
-              err.message || 'Unknown error',
-            );
-          });
-        }
-      } catch (err) {
-        console.debug(
-          'Failed to open browser:',
-          err instanceof Error ? err.message : 'Unknown error',
-        );
-      }
+    // Try to open browser if not suppressed
+    if (!config.isBrowserLaunchSuppressed()) {
+      await launchBrowser(deviceAuth.verification_uri_complete);
     }
 
-    // Emit auth progress event
-    qwenOAuth2Events.emit(
-      QwenOAuth2Event.AuthProgress,
-      'polling',
-      'Waiting for authorization...',
-    );
-
+    emitAuthProgress('polling', 'Waiting for authorization...');
     console.debug('Waiting for authorization...\n');
 
     // Poll for the token
@@ -653,11 +762,9 @@ async function authWithQwenDeviceFlow(
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       // Check if authentication was cancelled
-      if (isCancelled) {
-        const message = 'Authentication cancelled by user.';
-        console.debug('\n' + message);
-        qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
-        return { success: false, reason: 'cancelled', message };
+      const cancellationResult = checkCancellation();
+      if (cancellationResult) {
+        return cancellationResult;
       }
 
       try {
@@ -700,9 +807,7 @@ async function authWithQwenDeviceFlow(
             // minimal stub; cache invalidation is best-effort and should not break auth.
           }
 
-          // Emit auth progress success event
-          qwenOAuth2Events.emit(
-            QwenOAuth2Event.AuthProgress,
+          emitAuthProgress(
             'success',
             'Authentication successful! Access token obtained.',
           );
@@ -725,9 +830,7 @@ async function authWithQwenDeviceFlow(
             pollInterval = 2000; // Reset to default interval
           }
 
-          // Emit polling progress event
-          qwenOAuth2Events.emit(
-            QwenOAuth2Event.AuthProgress,
+          emitAuthProgress(
             'polling',
             `Polling... (attempt ${attempt + 1}/${maxAttempts})`,
           );
@@ -757,15 +860,9 @@ async function authWithQwenDeviceFlow(
           });
 
           // Check for cancellation after waiting
-          if (isCancelled) {
-            const message = 'Authentication cancelled by user.';
-            console.debug('\n' + message);
-            qwenOAuth2Events.emit(
-              QwenOAuth2Event.AuthProgress,
-              'error',
-              message,
-            );
-            return { success: false, reason: 'cancelled', message };
+          const cancellationResult = checkCancellation();
+          if (cancellationResult) {
+            return cancellationResult;
           }
 
           continue;
@@ -793,15 +890,17 @@ async function authWithQwenDeviceFlow(
           message: string,
           eventType: 'error' | 'rate_limit' = 'error',
         ): AuthResult => {
-          qwenOAuth2Events.emit(
-            QwenOAuth2Event.AuthProgress,
-            eventType,
-            message,
-          );
+          emitAuthProgress(eventType, message);
           console.error('\n' + message);
           return { success: false, reason, message };
         };
 
+        // Check for cancellation first
+        const cancellationResult = checkCancellation();
+        if (cancellationResult) {
+          return cancellationResult;
+        }
+
         // Handle credential caching failures - stop polling immediately
         if (errorMessage.includes('Failed to cache credentials')) {
           return handleError('error', errorMessage);
@@ -825,26 +924,14 @@ async function authWithQwenDeviceFlow(
         }
 
         const message = `Error polling for token: ${errorMessage}`;
-        qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
-
-        if (isCancelled) {
-          const message = 'Authentication cancelled by user.';
-          return { success: false, reason: 'cancelled', message };
-        }
+        emitAuthProgress('error', message);
 
         await new Promise((resolve) => setTimeout(resolve, pollInterval));
       }
     }
 
     const timeoutMessage = 'Authorization timeout, please restart the process.';
-
-    // Emit timeout error event
-    qwenOAuth2Events.emit(
-      QwenOAuth2Event.AuthProgress,
-      'timeout',
-      timeoutMessage,
-    );
-
+    emitAuthProgress('timeout', timeoutMessage);
     console.error('\n' + timeoutMessage);
     return { success: false, reason: 'timeout', message: timeoutMessage };
   } catch (error: unknown) {
@@ -853,7 +940,7 @@ async function authWithQwenDeviceFlow(
     });
     const message = `Device authorization flow failed: ${fullErrorMessage}`;
 
-    qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
+    emitAuthProgress('error', message);
     console.error(message);
     return { success: false, reason: 'error', message };
   } finally {

packages/sdk-typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/sdk",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "TypeScript SDK for programmatic access to qwen-code CLI",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

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

@@ -125,8 +125,9 @@ function normalizeForRegex(dirPath: string): string {
 function tryResolveCliFromImportMeta(): string | null {
   try {
     if (typeof import.meta !== 'undefined' && import.meta.url) {
-      const cliUrl = new URL('./cli/cli.js', import.meta.url);
-      const cliPath = fileURLToPath(cliUrl);
+      const currentFilePath = fileURLToPath(import.meta.url);
+      const currentDir = path.dirname(currentFilePath);
+      const cliPath = path.join(currentDir, 'cli', 'cli.js');
       if (fs.existsSync(cliPath)) {
         return cliPath;
       }