fix: provide available models of all configured authTypes

.gitignore

@@ -12,7 +12,7 @@
 !.gemini/config.yaml
 !.gemini/commands/
 
-# Note: .qwen-code-clipboard/ is NOT in gitignore so Qwen Code can access pasted images
+# Note: .gemini-clipboard/ is NOT in gitignore so Gemini can access pasted images
 
 # Dependency directory
 node_modules

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

@@ -34,6 +34,10 @@ import { ExtensionEnablementManager } from '../config/extensions/extensionEnable
 
 // Import the modular Session class
 import { Session } from './session/Session.js';
+import {
+  formatAcpModelId,
+  parseAcpBaseModelId,
+} from '../utils/acpModelUtils.js';
 
 export async function runAcpAgent(
   config: Config,
@@ -381,15 +385,24 @@ class GeminiAgent {
   private buildAvailableModels(
     config: Config,
   ): acp.NewSessionResponse['models'] {
-    const currentModelId = (
+    const rawCurrentModelId = (
       config.getModel() ||
       this.config.getModel() ||
       ''
     ).trim();
-    const availableModels = config.getAvailableModels();
+    const currentAuthType = config.getAuthType();
+    const allConfiguredModels = config.getAllConfiguredModels();
+
+    const baseCurrentModelId = parseAcpBaseModelId(rawCurrentModelId);
+    const currentModelId =
+      currentAuthType && baseCurrentModelId
+        ? formatAcpModelId(baseCurrentModelId, currentAuthType)
+        : baseCurrentModelId;
+
+    const availableModels = allConfiguredModels;
 
     const mappedAvailableModels = availableModels.map((model) => ({
-      modelId: model.id,
+      modelId: formatAcpModelId(model.id, model.authType),
       name: model.label,
       description: model.description ?? null,
       _meta: {
@@ -406,7 +419,7 @@ class GeminiAgent {
         name: currentModelId,
         description: null,
         _meta: {
-          contextLimit: tokenLimit(currentModelId),
+          contextLimit: tokenLimit(baseCurrentModelId),
         },
       });
     }

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

@@ -7,7 +7,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Session } from './Session.js';
 import type { Config, GeminiChat } from '@qwen-code/qwen-code-core';
-import { ApprovalMode } from '@qwen-code/qwen-code-core';
+import { ApprovalMode, AuthType } from '@qwen-code/qwen-code-core';
 import type * as acp from '../acp.js';
 import type { LoadedSettings } from '../../config/settings.js';
 import * as nonInteractiveCliCommands from '../../nonInteractiveCliCommands.js';
@@ -24,14 +24,19 @@ describe('Session', () => {
   let mockSettings: LoadedSettings;
   let session: Session;
   let currentModel: string;
-  let setModelSpy: ReturnType<typeof vi.fn>;
+  let currentAuthType: AuthType;
+  let switchModelSpy: ReturnType<typeof vi.fn>;
   let getAvailableCommandsSpy: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     currentModel = 'qwen3-code-plus';
-    setModelSpy = vi.fn().mockImplementation(async (modelId: string) => {
-      currentModel = modelId;
-    });
+    currentAuthType = AuthType.USE_OPENAI;
+    switchModelSpy = vi
+      .fn()
+      .mockImplementation(async (authType: AuthType, modelId: string) => {
+        currentAuthType = authType;
+        currentModel = modelId;
+      });
 
     mockChat = {
       sendMessageStream: vi.fn(),
@@ -40,8 +45,9 @@ describe('Session', () => {
 
     mockConfig = {
       setApprovalMode: vi.fn(),
-      setModel: setModelSpy,
+      switchModel: switchModelSpy,
       getModel: vi.fn().mockImplementation(() => currentModel),
+      getAuthType: vi.fn().mockImplementation(() => currentAuthType),
     } as unknown as Config;
 
     mockClient = {
@@ -88,17 +94,25 @@ describe('Session', () => {
 
   describe('setModel', () => {
     it('sets model via config and returns current model', async () => {
+      const requested = `qwen3-coder-plus(${AuthType.USE_OPENAI})`;
       const result = await session.setModel({
         sessionId: 'test-session-id',
-        modelId: '  qwen3-coder-plus  ',
+        modelId: `  ${requested}  `,
       });
 
-      expect(mockConfig.setModel).toHaveBeenCalledWith('qwen3-coder-plus', {
-        reason: 'user_request_acp',
-        context: 'session/set_model',
-      });
+      expect(mockConfig.switchModel).toHaveBeenCalledWith(
+        AuthType.USE_OPENAI,
+        'qwen3-coder-plus',
+        undefined,
+        {
+          reason: 'user_request_acp',
+          context: 'session/set_model',
+        },
+      );
       expect(mockConfig.getModel).toHaveBeenCalled();
-      expect(result).toEqual({ modelId: 'qwen3-coder-plus' });
+      expect(result).toEqual({
+        modelId: `qwen3-coder-plus(${AuthType.USE_OPENAI})`,
+      });
     });
 
     it('rejects empty/whitespace model IDs', async () => {
@@ -109,17 +123,17 @@ describe('Session', () => {
         }),
       ).rejects.toThrow('Invalid params');
 
-      expect(mockConfig.setModel).not.toHaveBeenCalled();
+      expect(mockConfig.switchModel).not.toHaveBeenCalled();
     });
 
-    it('propagates errors from config.setModel', async () => {
+    it('propagates errors from config.switchModel', async () => {
       const configError = new Error('Invalid model');
-      setModelSpy.mockRejectedValueOnce(configError);
+      switchModelSpy.mockRejectedValueOnce(configError);
 
       await expect(
         session.setModel({
           sessionId: 'test-session-id',
-          modelId: 'invalid-model',
+          modelId: `invalid-model(${AuthType.USE_OPENAI})`,
         }),
       ).rejects.toThrow('Invalid model');
     });

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

@@ -19,6 +19,7 @@ import type {
   SubAgentEventEmitter,
 } from '@qwen-code/qwen-code-core';
 import {
+  AuthType,
   ApprovalMode,
   convertToFunctionResponse,
   DiscoveredMCPTool,
@@ -58,6 +59,10 @@ import type {
   CurrentModeUpdate,
 } from '../schema.js';
 import { isSlashCommand } from '../../ui/utils/commandUtils.js';
+import {
+  formatAcpModelId,
+  parseAcpModelOption,
+} from '../../utils/acpModelUtils.js';
 
 // Import modular session components
 import type { SessionContext, ToolCallStartParams } from './types.js';
@@ -355,23 +360,39 @@ export class Session implements SessionContext {
    * Validates the model ID and switches the model via Config.
    */
   async setModel(params: SetModelRequest): Promise<SetModelResponse> {
-    const modelId = params.modelId.trim();
+    const rawModelId = params.modelId.trim();
 
-    if (!modelId) {
+    if (!rawModelId) {
       throw acp.RequestError.invalidParams('modelId cannot be empty');
     }
 
-    // Attempt to set the model using config
-    await this.config.setModel(modelId, {
-      reason: 'user_request_acp',
-      context: 'session/set_model',
-    });
+    const parsed = parseAcpModelOption(rawModelId);
+    const previousAuthType = this.config.getAuthType?.();
+    const selectedAuthType = parsed.authType ?? previousAuthType;
+
+    if (!selectedAuthType) {
+      throw acp.RequestError.invalidParams('authType cannot be determined');
+    }
+
+    await this.config.switchModel(
+      selectedAuthType,
+      parsed.modelId,
+      selectedAuthType !== previousAuthType &&
+        selectedAuthType === AuthType.QWEN_OAUTH
+        ? { requireCachedCredentials: true }
+        : undefined,
+      {
+        reason: 'user_request_acp',
+        context: 'session/set_model',
+      },
+    );
 
     // Get updated model info
     const currentModel = this.config.getModel();
+    const currentAuthType = this.config.getAuthType?.() ?? selectedAuthType;
 
     return {
-      modelId: currentModel,
+      modelId: formatAcpModelId(currentModel, currentAuthType),
     };
   }
 

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

@@ -376,7 +376,7 @@ describe('InputPrompt', () => {
     it('should handle Ctrl+V when clipboard has an image', async () => {
       vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
       vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(
-        '/test/.qwen-code-clipboard/clipboard-123.png',
+        '/test/.gemini-clipboard/clipboard-123.png',
       );
 
       const { stdin, unmount } = renderWithProviders(
@@ -436,7 +436,7 @@ describe('InputPrompt', () => {
     it('should insert image path at cursor position with proper spacing', async () => {
       const imagePath = path.join(
         'test',
-        '.qwen-code-clipboard',
+        '.gemini-clipboard',
         'clipboard-456.png',
       );
       vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);

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

@@ -47,30 +47,36 @@ const renderComponent = (
     setValue: vi.fn(),
   } as unknown as LoadedSettings;
 
-  const mockConfig = contextValue
-    ? ({
-        // --- Functions used by ModelDialog ---
-        getModel: vi.fn(() => MAINLINE_CODER),
-        setModel: vi.fn().mockResolvedValue(undefined),
-        switchModel: vi.fn().mockResolvedValue(undefined),
-        getAuthType: vi.fn(() => 'qwen-oauth'),
+  const mockConfig = {
+    // --- Functions used by ModelDialog ---
+    getModel: vi.fn(() => MAINLINE_CODER),
+    setModel: vi.fn().mockResolvedValue(undefined),
+    switchModel: vi.fn().mockResolvedValue(undefined),
+    getAuthType: vi.fn(() => 'qwen-oauth'),
+    getAllConfiguredModels: vi.fn(() =>
+      AVAILABLE_MODELS_QWEN.map((m) => ({
+        id: m.id,
+        label: m.label,
+        description: m.description || '',
+        authType: AuthType.QWEN_OAUTH,
+      })),
+    ),
 
-        // --- Functions used by ClearcutLogger ---
-        getUsageStatisticsEnabled: vi.fn(() => true),
-        getSessionId: vi.fn(() => 'mock-session-id'),
-        getDebugMode: vi.fn(() => false),
-        getContentGeneratorConfig: vi.fn(() => ({
-          authType: AuthType.QWEN_OAUTH,
-          model: MAINLINE_CODER,
-        })),
-        getUseSmartEdit: vi.fn(() => false),
-        getUseModelRouter: vi.fn(() => false),
-        getProxy: vi.fn(() => undefined),
+    // --- Functions used by ClearcutLogger ---
+    getUsageStatisticsEnabled: vi.fn(() => true),
+    getSessionId: vi.fn(() => 'mock-session-id'),
+    getDebugMode: vi.fn(() => false),
+    getContentGeneratorConfig: vi.fn(() => ({
+      authType: AuthType.QWEN_OAUTH,
+      model: MAINLINE_CODER,
+    })),
+    getUseSmartEdit: vi.fn(() => false),
+    getUseModelRouter: vi.fn(() => false),
+    getProxy: vi.fn(() => undefined),
 
-        // --- Spread test-specific overrides ---
-        ...contextValue,
-      } as unknown as Config)
-    : undefined;
+    // --- Spread test-specific overrides ---
+    ...(contextValue ?? {}),
+  } as unknown as Config;
 
   const renderResult = render(
     <SettingsContext.Provider value={mockSettings}>
@@ -308,6 +314,14 @@ describe('<ModelDialog />', () => {
             {
               getModel: mockGetModel,
               getAuthType: mockGetAuthType,
+              getAllConfiguredModels: vi.fn(() =>
+                AVAILABLE_MODELS_QWEN.map((m) => ({
+                  id: m.id,
+                  label: m.label,
+                  description: m.description || '',
+                  authType: AuthType.QWEN_OAUTH,
+                })),
+              ),
             } as unknown as Config
           }
         >
@@ -322,6 +336,14 @@ describe('<ModelDialog />', () => {
     const newMockConfig = {
       getModel: mockGetModel,
       getAuthType: mockGetAuthType,
+      getAllConfiguredModels: vi.fn(() =>
+        AVAILABLE_MODELS_QWEN.map((m) => ({
+          id: m.id,
+          label: m.label,
+          description: m.description || '',
+          authType: AuthType.QWEN_OAUTH,
+        })),
+      ),
     } as unknown as Config;
 
     rerender(

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

@@ -11,6 +11,7 @@ import {
   AuthType,
   ModelSlashCommandEvent,
   logModelSlashCommand,
+  type AvailableModel as CoreAvailableModel,
   type ContentGeneratorConfig,
   type ContentGeneratorConfigSource,
   type ContentGeneratorConfigSources,
@@ -21,10 +22,7 @@ import { DescriptiveRadioButtonSelect } from './shared/DescriptiveRadioButtonSel
 import { ConfigContext } from '../contexts/ConfigContext.js';
 import { UIStateContext } from '../contexts/UIStateContext.js';
 import { useSettings } from '../contexts/SettingsContext.js';
-import {
-  getAvailableModelsForAuthType,
-  MAINLINE_CODER,
-} from '../models/availableModels.js';
+import { MAINLINE_CODER } from '../models/availableModels.js';
 import { getPersistScopeForModelSelection } from '../../config/modelProvidersScope.js';
 import { t } from '../../i18n/index.js';
 
@@ -154,13 +152,17 @@ export function ModelDialog({ onClose }: ModelDialogProps): React.JSX.Element {
   const sources = readSourcesFromConfig(config);
 
   const availableModelEntries = useMemo(() => {
-    const allAuthTypes = Object.values(AuthType) as AuthType[];
-    const modelsByAuthType = allAuthTypes
-      .map((t) => ({
-        authType: t,
-        models: getAvailableModelsForAuthType(t, config ?? undefined),
-      }))
-      .filter((x) => x.models.length > 0);
+    const allModels = config ? config.getAllConfiguredModels() : [];
+
+    // Group models by authType
+    const modelsByAuthTypeMap = new Map<AuthType, CoreAvailableModel[]>();
+    for (const model of allModels) {
+      const authType = model.authType;
+      if (!modelsByAuthTypeMap.has(authType)) {
+        modelsByAuthTypeMap.set(authType, []);
+      }
+      modelsByAuthTypeMap.get(authType)!.push(model);
+    }
 
     // Fixed order: qwen-oauth first, then others in a stable order
     const authTypeOrder: AuthType[] = [
@@ -171,15 +173,14 @@ export function ModelDialog({ onClose }: ModelDialogProps): React.JSX.Element {
       AuthType.USE_VERTEX_AI,
     ];
 
-    // Filter to only include authTypes that have models
-    const availableAuthTypes = new Set(modelsByAuthType.map((x) => x.authType));
+    // Filter to only include authTypes that have models and maintain order
+    const availableAuthTypes = new Set(modelsByAuthTypeMap.keys());
     const orderedAuthTypes = authTypeOrder.filter((t) =>
       availableAuthTypes.has(t),
     );
 
     return orderedAuthTypes.flatMap((t) => {
-      const models =
-        modelsByAuthType.find((x) => x.authType === t)?.models ?? [];
+      const models = modelsByAuthTypeMap.get(t) ?? [];
       return models.map((m) => ({ authType: t, model: m }));
     });
   }, [config]);

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

@@ -1,17 +1,12 @@
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import {
-  execCommand,
-  ensureClipboardImageDir,
-  generateClipboardImageFilename,
-  cleanupOldClipboardImages as cleanupOldImages,
-} from '@qwen-code/qwen-code-core';
+import { execCommand } from '@qwen-code/qwen-code-core';
 
 /**
  * Checks if the system clipboard contains an image (macOS only for now)
@@ -35,7 +30,6 @@ export async function clipboardHasImage(): Promise<boolean> {
 
 /**
  * Saves the image from clipboard to a temporary file (macOS only for now)
- * Uses osascript to read from system clipboard and save to file.
  * @param targetDir The target directory to create temp files within
  * @returns The path to the saved image file, or null if no image or error
  */
@@ -50,7 +44,11 @@ export async function saveClipboardImage(
     // Create a temporary directory for clipboard images within the target directory
     // This avoids security restrictions on paths outside the target directory
     const baseDir = targetDir || process.cwd();
-    const tempDir = await ensureClipboardImageDir(baseDir);
+    const tempDir = path.join(baseDir, '.gemini-clipboard');
+    await fs.mkdir(tempDir, { recursive: true });
+
+    // Generate a unique filename with timestamp
+    const timestamp = new Date().getTime();
 
     // Try different image formats in order of preference
     const formats = [
@@ -63,7 +61,7 @@ export async function saveClipboardImage(
     for (const format of formats) {
       const tempFilePath = path.join(
         tempDir,
-        generateClipboardImageFilename(format.extension),
+        `clipboard-${timestamp}.${format.extension}`,
       );
 
       // Try to save clipboard as this format
@@ -120,6 +118,28 @@ export async function saveClipboardImage(
 export async function cleanupOldClipboardImages(
   targetDir?: string,
 ): Promise<void> {
-  const baseDir = targetDir || process.cwd();
-  await cleanupOldImages(baseDir);
+  try {
+    const baseDir = targetDir || process.cwd();
+    const tempDir = path.join(baseDir, '.gemini-clipboard');
+    const files = await fs.readdir(tempDir);
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+
+    for (const file of files) {
+      if (
+        file.startsWith('clipboard-') &&
+        (file.endsWith('.png') ||
+          file.endsWith('.jpg') ||
+          file.endsWith('.tiff') ||
+          file.endsWith('.gif'))
+      ) {
+        const filePath = path.join(tempDir, file);
+        const stats = await fs.stat(filePath);
+        if (stats.mtimeMs < oneHourAgo) {
+          await fs.unlink(filePath);
+        }
+      }
+    }
+  } catch {
+    // Ignore errors in cleanup
+  }
 }

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

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { AuthType } from '@qwen-code/qwen-code-core';
+import {
+  formatAcpModelId,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+} from './acpModelUtils.js';
+
+describe('acpModelUtils', () => {
+  it('formats modelId(authType)', () => {
+    expect(formatAcpModelId('qwen3', AuthType.QWEN_OAUTH)).toBe(
+      `qwen3(${AuthType.QWEN_OAUTH})`,
+    );
+  });
+
+  it('extracts base model id when string ends with parentheses', () => {
+    expect(parseAcpBaseModelId(`qwen3(${AuthType.USE_OPENAI})`)).toBe('qwen3');
+  });
+
+  it('does not strip when parentheses are not a trailing suffix', () => {
+    expect(parseAcpBaseModelId('qwen3(x) y')).toBe('qwen3(x) y');
+  });
+
+  it('parses modelId and validates authType', () => {
+    expect(parseAcpModelOption(` qwen3(${AuthType.USE_OPENAI}) `)).toEqual({
+      modelId: 'qwen3',
+      authType: AuthType.USE_OPENAI,
+    });
+  });
+
+  it('returns trimmed input as modelId when authType is invalid', () => {
+    expect(parseAcpModelOption('qwen3(not-a-real-auth)')).toEqual({
+      modelId: 'qwen3(not-a-real-auth)',
+    });
+  });
+});

packages/cli/src/utils/acpModelUtils.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AuthType } from '@qwen-code/qwen-code-core';
+import { z } from 'zod';
+
+/**
+ * ACP model IDs are represented as `${modelId}(${authType})` in the ACP protocol.
+ */
+export function formatAcpModelId(modelId: string, authType: AuthType): string {
+  return `${modelId}(${authType})`;
+}
+
+/**
+ * Extracts the base model id from an ACP model id string.
+ *
+ * If the string ends with `(...)`, the suffix is removed; otherwise returns the
+ * trimmed input as-is.
+ */
+export function parseAcpBaseModelId(value: string): string {
+  const trimmed = value.trim();
+  const closeIdx = trimmed.lastIndexOf(')');
+  const openIdx = trimmed.lastIndexOf('(');
+  if (openIdx >= 0 && closeIdx === trimmed.length - 1 && openIdx < closeIdx) {
+    return trimmed.slice(0, openIdx);
+  }
+  return trimmed;
+}
+
+/**
+ * Parses an ACP model option string into `{ modelId, authType? }`.
+ *
+ * If the string ends with `(...)` and `...` is a valid `AuthType`, returns both;
+ * otherwise returns the trimmed input as `modelId` only.
+ */
+export function parseAcpModelOption(input: string): {
+  modelId: string;
+  authType?: AuthType;
+} {
+  const trimmed = input.trim();
+  const closeIdx = trimmed.lastIndexOf(')');
+  const openIdx = trimmed.lastIndexOf('(');
+  if (openIdx >= 0 && closeIdx === trimmed.length - 1 && openIdx < closeIdx) {
+    const maybeModelId = trimmed.slice(0, openIdx);
+    const maybeAuthType = trimmed.slice(openIdx + 1, closeIdx);
+    const parsedAuthType = z.nativeEnum(AuthType).safeParse(maybeAuthType);
+    if (parsedAuthType.success) {
+      return { modelId: maybeModelId, authType: parsedAuthType.data };
+    }
+  }
+  return { modelId: trimmed };
+}

packages/core/src/config/config.ts

@@ -921,6 +921,14 @@ export class Config {
     return this._modelsConfig.getAvailableModelsForAuthType(authType);
   }
 
+  /**
+   * Get all configured models across authTypes.
+   * Delegates to ModelsConfig.
+   */
+  getAllConfiguredModels(authTypes?: AuthType[]): AvailableModel[] {
+    return this._modelsConfig.getAllConfiguredModels(authTypes);
+  }
+
   /**
    * Switch authType+model via registry-backed selection.
    * This triggers a refresh of the ContentGenerator when required (always on authType changes).

packages/core/src/index.ts

@@ -76,7 +76,6 @@ export * from './utils/subagentGenerator.js';
 export * from './utils/projectSummary.js';
 export * from './utils/promptIdContext.js';
 export * from './utils/thoughtUtils.js';
-export * from './utils/clipboardImageStorage.js';
 
 // Config resolution utilities
 export * from './utils/configResolver.js';

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

@@ -679,8 +679,8 @@ describe('ModelsConfig', () => {
     expect(modelsConfig.getGenerationConfig().model).toBe('updated-model');
   });
 
-  describe('getAllAvailableModels', () => {
-    it('should return all models across all authTypes', () => {
+  describe('getAllConfiguredModels', () => {
+    it('should return all models across all authTypes and put qwen-oauth first', () => {
       const modelProvidersConfig: ModelProvidersConfig = {
         openai: [
           {
@@ -718,7 +718,23 @@ describe('ModelsConfig', () => {
         modelProvidersConfig,
       });
 
-      const allModels = modelsConfig.getAllAvailableModels();
+      const allModels = modelsConfig.getAllConfiguredModels();
+
+      // qwen-oauth models should be ordered first
+      const firstNonQwenIndex = allModels.findIndex(
+        (m) => m.authType !== AuthType.QWEN_OAUTH,
+      );
+      expect(firstNonQwenIndex).toBeGreaterThan(0);
+      expect(
+        allModels
+          .slice(0, firstNonQwenIndex)
+          .every((m) => m.authType === AuthType.QWEN_OAUTH),
+      ).toBe(true);
+      expect(
+        allModels
+          .slice(firstNonQwenIndex)
+          .every((m) => m.authType !== AuthType.QWEN_OAUTH),
+      ).toBe(true);
 
       // Should include qwen-oauth models (hard-coded)
       const qwenModels = allModels.filter(
@@ -752,7 +768,7 @@ describe('ModelsConfig', () => {
     it('should return empty array when no models are registered', () => {
       const modelsConfig = new ModelsConfig();
 
-      const allModels = modelsConfig.getAllAvailableModels();
+      const allModels = modelsConfig.getAllConfiguredModels();
 
       // Should still include qwen-oauth models (hard-coded)
       expect(allModels.length).toBeGreaterThan(0);
@@ -782,7 +798,7 @@ describe('ModelsConfig', () => {
         modelProvidersConfig,
       });
 
-      const allModels = modelsConfig.getAllAvailableModels();
+      const allModels = modelsConfig.getAllConfiguredModels();
       const testModel = allModels.find((m) => m.id === 'test-model');
 
       expect(testModel).toBeDefined();
@@ -793,5 +809,56 @@ describe('ModelsConfig', () => {
       expect(testModel?.isVision).toBe(true);
       expect(testModel?.capabilities?.vision).toBe(true);
     });
+
+    it('should support filtering by authTypes and still put qwen-oauth first when included', () => {
+      const modelProvidersConfig: ModelProvidersConfig = {
+        openai: [
+          {
+            id: 'openai-model-1',
+            name: 'OpenAI Model 1',
+            baseUrl: 'https://api.openai.com/v1',
+            envKey: 'OPENAI_API_KEY',
+          },
+        ],
+        anthropic: [
+          {
+            id: 'anthropic-model-1',
+            name: 'Anthropic Model 1',
+            baseUrl: 'https://api.anthropic.com/v1',
+            envKey: 'ANTHROPIC_API_KEY',
+          },
+        ],
+      };
+
+      const modelsConfig = new ModelsConfig({
+        modelProvidersConfig,
+      });
+
+      // Filter: OpenAI only (should not include qwen-oauth)
+      const openaiOnly = modelsConfig.getAllConfiguredModels([
+        AuthType.USE_OPENAI,
+      ]);
+      expect(openaiOnly.every((m) => m.authType === AuthType.USE_OPENAI)).toBe(
+        true,
+      );
+      expect(openaiOnly.map((m) => m.id)).toContain('openai-model-1');
+
+      // Filter: include qwen-oauth but request it later -> still ordered first
+      const withQwen = modelsConfig.getAllConfiguredModels([
+        AuthType.USE_OPENAI,
+        AuthType.QWEN_OAUTH,
+        AuthType.USE_ANTHROPIC,
+      ]);
+      expect(withQwen.length).toBeGreaterThan(0);
+      const firstNonQwenIndex = withQwen.findIndex(
+        (m) => m.authType !== AuthType.QWEN_OAUTH,
+      );
+      expect(firstNonQwenIndex).toBeGreaterThan(0);
+      expect(
+        withQwen
+          .slice(0, firstNonQwenIndex)
+          .every((m) => m.authType === AuthType.QWEN_OAUTH),
+      ).toBe(true);
+    });
   });
 });

packages/core/src/models/modelsConfig.ts

@@ -204,13 +204,40 @@ export class ModelsConfig {
   }
 
   /**
-   * Get all available models across all authTypes
+   * Get all configured models across authTypes.
+   *
+   * Notes:
+   * - By default, returns models across all authTypes.
+   * - qwen-oauth models are always ordered first.
    */
-  getAllAvailableModels(): AvailableModel[] {
+  getAllConfiguredModels(authTypes?: AuthType[]): AvailableModel[] {
+    const inputAuthTypes =
+      authTypes && authTypes.length > 0 ? authTypes : Object.values(AuthType);
+
+    // De-duplicate while preserving the original order.
+    const seen = new Set<AuthType>();
+    const uniqueAuthTypes: AuthType[] = [];
+    for (const authType of inputAuthTypes) {
+      if (!seen.has(authType)) {
+        seen.add(authType);
+        uniqueAuthTypes.push(authType);
+      }
+    }
+
+    // Force qwen-oauth to the front (if requested / defaulted in).
+    const orderedAuthTypes: AuthType[] = [];
+    if (uniqueAuthTypes.includes(AuthType.QWEN_OAUTH)) {
+      orderedAuthTypes.push(AuthType.QWEN_OAUTH);
+    }
+    for (const authType of uniqueAuthTypes) {
+      if (authType !== AuthType.QWEN_OAUTH) {
+        orderedAuthTypes.push(authType);
+      }
+    }
+
     const allModels: AvailableModel[] = [];
-    for (const authType of Object.values(AuthType)) {
-      const models = this.modelRegistry.getModelsForAuthType(authType);
-      allModels.push(...models);
+    for (const authType of orderedAuthTypes) {
+      allModels.push(...this.modelRegistry.getModelsForAuthType(authType));
     }
     return allModels;
   }

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

@@ -1,246 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as fsSync from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import {
-  CLIPBOARD_IMAGE_DIR,
-  CLEANUP_THRESHOLD_MS,
-  SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS,
-  getClipboardImageDir,
-  ensureClipboardImageDir,
-  ensureClipboardImageDirSync,
-  generateClipboardImageFilename,
-  saveBase64Image,
-  saveBase64ImageSync,
-  cleanupOldClipboardImages,
-  isSupportedClipboardImageExtension,
-} from './clipboardImageStorage.js';
-
-describe('clipboardImageStorage', () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    // Create a temporary directory for tests
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'clipboard-test-'));
-  });
-
-  afterEach(async () => {
-    // Clean up temporary directory
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe('constants', () => {
-    it('should have correct clipboard image directory name', () => {
-      expect(CLIPBOARD_IMAGE_DIR).toBe('.qwen-code-clipboard');
-    });
-
-    it('should have correct cleanup threshold (1 hour)', () => {
-      expect(CLEANUP_THRESHOLD_MS).toBe(60 * 60 * 1000);
-    });
-
-    it('should support common image extensions', () => {
-      expect(SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS).toContain('.png');
-      expect(SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS).toContain('.jpg');
-      expect(SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS).toContain('.jpeg');
-      expect(SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS).toContain('.gif');
-      expect(SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS).toContain('.webp');
-    });
-  });
-
-  describe('getClipboardImageDir', () => {
-    it('should return correct path', () => {
-      const result = getClipboardImageDir('/workspace');
-      expect(result).toBe(path.join('/workspace', '.qwen-code-clipboard'));
-    });
-  });
-
-  describe('ensureClipboardImageDir', () => {
-    it('should create directory if not exists', async () => {
-      const dir = await ensureClipboardImageDir(tempDir);
-      expect(dir).toBe(path.join(tempDir, CLIPBOARD_IMAGE_DIR));
-
-      const stats = await fs.stat(dir);
-      expect(stats.isDirectory()).toBe(true);
-    });
-
-    it('should not fail if directory already exists', async () => {
-      await ensureClipboardImageDir(tempDir);
-      const dir = await ensureClipboardImageDir(tempDir);
-      expect(dir).toBe(path.join(tempDir, CLIPBOARD_IMAGE_DIR));
-    });
-  });
-
-  describe('ensureClipboardImageDirSync', () => {
-    it('should create directory if not exists', () => {
-      const dir = ensureClipboardImageDirSync(tempDir);
-      expect(dir).toBe(path.join(tempDir, CLIPBOARD_IMAGE_DIR));
-      expect(fsSync.existsSync(dir)).toBe(true);
-    });
-  });
-
-  describe('generateClipboardImageFilename', () => {
-    it('should generate filename with timestamp and extension', () => {
-      const filename = generateClipboardImageFilename('.png');
-      expect(filename).toMatch(/^clipboard-\d+\.png$/);
-    });
-
-    it('should handle extension without dot', () => {
-      const filename = generateClipboardImageFilename('jpg');
-      expect(filename).toMatch(/^clipboard-\d+\.jpg$/);
-    });
-  });
-
-  describe('saveBase64Image', () => {
-    it('should save base64 image to file', async () => {
-      // Simple 1x1 red PNG in base64
-      const base64Data =
-        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==';
-
-      const relativePath = await saveBase64Image(
-        base64Data,
-        'test.png',
-        tempDir,
-      );
-
-      expect(relativePath).not.toBeNull();
-      expect(relativePath).toMatch(
-        /^\.qwen-code-clipboard\/clipboard-\d+\.png$/,
-      );
-
-      const fullPath = path.join(tempDir, relativePath!);
-      const stats = await fs.stat(fullPath);
-      expect(stats.size).toBeGreaterThan(0);
-    });
-
-    it('should handle data URL format', async () => {
-      const base64Data =
-        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==';
-
-      const relativePath = await saveBase64Image(
-        base64Data,
-        'test.png',
-        tempDir,
-      );
-
-      expect(relativePath).not.toBeNull();
-
-      const fullPath = path.join(tempDir, relativePath!);
-      const stats = await fs.stat(fullPath);
-      expect(stats.size).toBeGreaterThan(0);
-    });
-
-    it('should use default extension if not provided', async () => {
-      const base64Data =
-        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==';
-
-      const relativePath = await saveBase64Image(base64Data, 'noext', tempDir);
-
-      expect(relativePath).toMatch(/\.png$/);
-    });
-  });
-
-  describe('saveBase64ImageSync', () => {
-    it('should save base64 image to file synchronously', () => {
-      const base64Data =
-        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==';
-
-      const relativePath = saveBase64ImageSync(base64Data, 'test.png', tempDir);
-
-      expect(relativePath).not.toBeNull();
-      expect(relativePath).toMatch(
-        /^\.qwen-code-clipboard\/clipboard-\d+\.png$/,
-      );
-
-      const fullPath = path.join(tempDir, relativePath!);
-      expect(fsSync.existsSync(fullPath)).toBe(true);
-    });
-  });
-
-  describe('cleanupOldClipboardImages', () => {
-    it('should remove files older than threshold', async () => {
-      // Create clipboard directory
-      const clipboardDir = await ensureClipboardImageDir(tempDir);
-
-      // Create an old file
-      const oldFilePath = path.join(clipboardDir, 'clipboard-1234567890.png');
-      await fs.writeFile(oldFilePath, 'test');
-
-      // Set mtime to 2 hours ago
-      const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000);
-      await fs.utimes(oldFilePath, twoHoursAgo, twoHoursAgo);
-
-      // Create a new file
-      const newFilePath = path.join(clipboardDir, 'clipboard-9999999999.png');
-      await fs.writeFile(newFilePath, 'test');
-
-      // Run cleanup
-      await cleanupOldClipboardImages(tempDir);
-
-      // Old file should be deleted
-      await expect(fs.access(oldFilePath)).rejects.toThrow();
-
-      // New file should still exist
-      await expect(fs.access(newFilePath)).resolves.toBeUndefined();
-    });
-
-    it('should not fail if directory does not exist', async () => {
-      // Should not throw
-      await expect(cleanupOldClipboardImages(tempDir)).resolves.toBeUndefined();
-    });
-
-    it('should only clean clipboard-* files', async () => {
-      const clipboardDir = await ensureClipboardImageDir(tempDir);
-
-      // Create a non-clipboard file
-      const otherFilePath = path.join(clipboardDir, 'other-file.png');
-      await fs.writeFile(otherFilePath, 'test');
-
-      // Set mtime to 2 hours ago
-      const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000);
-      await fs.utimes(otherFilePath, twoHoursAgo, twoHoursAgo);
-
-      // Run cleanup
-      await cleanupOldClipboardImages(tempDir);
-
-      // Other file should still exist
-      await expect(fs.access(otherFilePath)).resolves.toBeUndefined();
-    });
-  });
-
-  describe('isSupportedClipboardImageExtension', () => {
-    it('should return true for supported extensions', () => {
-      expect(isSupportedClipboardImageExtension('.png')).toBe(true);
-      expect(isSupportedClipboardImageExtension('.jpg')).toBe(true);
-      expect(isSupportedClipboardImageExtension('.jpeg')).toBe(true);
-      expect(isSupportedClipboardImageExtension('.gif')).toBe(true);
-      expect(isSupportedClipboardImageExtension('.webp')).toBe(true);
-    });
-
-    it('should return true for extensions without dot', () => {
-      expect(isSupportedClipboardImageExtension('png')).toBe(true);
-      expect(isSupportedClipboardImageExtension('jpg')).toBe(true);
-    });
-
-    it('should return false for unsupported extensions', () => {
-      expect(isSupportedClipboardImageExtension('.txt')).toBe(false);
-      expect(isSupportedClipboardImageExtension('.pdf')).toBe(false);
-      expect(isSupportedClipboardImageExtension('.doc')).toBe(false);
-    });
-
-    it('should be case insensitive', () => {
-      expect(isSupportedClipboardImageExtension('.PNG')).toBe(true);
-      expect(isSupportedClipboardImageExtension('.JPG')).toBe(true);
-    });
-  });
-});

packages/core/src/utils/clipboardImageStorage.ts

@@ -1,215 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fs from 'node:fs/promises';
-import * as fsSync from 'node:fs';
-import * as path from 'node:path';
-
-/**
- * Directory name for storing clipboard images
- * This directory is NOT in .gitignore so the AI can access pasted images
- */
-export const CLIPBOARD_IMAGE_DIR = '.qwen-code-clipboard';
-
-/**
- * Default cleanup threshold: 1 hour
- */
-export const CLEANUP_THRESHOLD_MS = 60 * 60 * 1000;
-
-/**
- * Supported image extensions for clipboard images
- */
-export const SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS = [
-  '.png',
-  '.jpg',
-  '.jpeg',
-  '.gif',
-  '.tiff',
-  '.webp',
-  '.bmp',
-];
-
-/**
- * Get the full path to the clipboard image directory
- * @param baseDir The base directory (usually workspace root)
- * @returns Full path to the clipboard image directory
- */
-export function getClipboardImageDir(baseDir: string): string {
-  return path.join(baseDir, CLIPBOARD_IMAGE_DIR);
-}
-
-/**
- * Ensure the clipboard image directory exists
- * @param baseDir The base directory (usually workspace root)
- * @returns Full path to the clipboard image directory
- */
-export async function ensureClipboardImageDir(
-  baseDir: string,
-): Promise<string> {
-  const dir = getClipboardImageDir(baseDir);
-  await fs.mkdir(dir, { recursive: true });
-  return dir;
-}
-
-/**
- * Ensure the clipboard image directory exists (sync version)
- * @param baseDir The base directory (usually workspace root)
- * @returns Full path to the clipboard image directory
- */
-export function ensureClipboardImageDirSync(baseDir: string): string {
-  const dir = getClipboardImageDir(baseDir);
-  if (!fsSync.existsSync(dir)) {
-    fsSync.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-
-/**
- * Generate a unique filename for a clipboard image
- * @param extension File extension (with or without dot)
- * @returns Generated filename like "clipboard-1234567890.png"
- */
-export function generateClipboardImageFilename(extension: string): string {
-  const timestamp = Date.now();
-  const ext = extension.startsWith('.') ? extension : `.${extension}`;
-  return `clipboard-${timestamp}${ext}`;
-}
-
-/**
- * Save a base64 encoded image to the clipboard image directory
- * @param base64Data Base64 encoded image data (with or without data URL prefix)
- * @param fileName Original filename or generated filename
- * @param baseDir The base directory (usually workspace root)
- * @returns Relative path from baseDir to the saved file, or null if failed
- */
-export async function saveBase64Image(
-  base64Data: string,
-  fileName: string,
-  baseDir: string,
-): Promise<string | null> {
-  try {
-    const dir = await ensureClipboardImageDir(baseDir);
-
-    // Generate unique filename
-    const ext = path.extname(fileName) || '.png';
-    const tempFileName = generateClipboardImageFilename(ext);
-    const tempFilePath = path.join(dir, tempFileName);
-
-    // Extract base64 data if it's a data URL
-    let pureBase64 = base64Data;
-    const dataUrlMatch = base64Data.match(/^data:[^;]+;base64,(.+)$/);
-    if (dataUrlMatch) {
-      pureBase64 = dataUrlMatch[1];
-    }
-
-    // Write file
-    const buffer = Buffer.from(pureBase64, 'base64');
-    await fs.writeFile(tempFilePath, buffer);
-
-    // Return relative path from baseDir
-    return path.relative(baseDir, tempFilePath);
-  } catch (error) {
-    console.error('[clipboardImageStorage] Failed to save image:', error);
-    return null;
-  }
-}
-
-/**
- * Save a base64 encoded image to the clipboard image directory (sync version)
- * @param base64Data Base64 encoded image data (with or without data URL prefix)
- * @param fileName Original filename or generated filename
- * @param baseDir The base directory (usually workspace root)
- * @returns Relative path from baseDir to the saved file, or null if failed
- */
-export function saveBase64ImageSync(
-  base64Data: string,
-  fileName: string,
-  baseDir: string,
-): string | null {
-  try {
-    const dir = ensureClipboardImageDirSync(baseDir);
-
-    // Generate unique filename
-    const ext = path.extname(fileName) || '.png';
-    const tempFileName = generateClipboardImageFilename(ext);
-    const tempFilePath = path.join(dir, tempFileName);
-
-    // Extract base64 data if it's a data URL
-    let pureBase64 = base64Data;
-    const dataUrlMatch = base64Data.match(/^data:[^;]+;base64,(.+)$/);
-    if (dataUrlMatch) {
-      pureBase64 = dataUrlMatch[1];
-    }
-
-    // Write file
-    const buffer = Buffer.from(pureBase64, 'base64');
-    fsSync.writeFileSync(tempFilePath, buffer);
-
-    // Return relative path from baseDir
-    return path.relative(baseDir, tempFilePath);
-  } catch (error) {
-    console.error('[clipboardImageStorage] Failed to save image:', error);
-    return null;
-  }
-}
-
-/**
- * Clean up old clipboard image files
- * Removes files older than the specified threshold
- * @param baseDir The base directory (usually workspace root)
- * @param thresholdMs Age threshold in milliseconds (default: 1 hour)
- */
-export async function cleanupOldClipboardImages(
-  baseDir: string,
-  thresholdMs: number = CLEANUP_THRESHOLD_MS,
-): Promise<void> {
-  try {
-    const dir = getClipboardImageDir(baseDir);
-
-    // Check if directory exists
-    try {
-      await fs.access(dir);
-    } catch {
-      // Directory doesn't exist, nothing to clean
-      return;
-    }
-
-    const files = await fs.readdir(dir);
-    const cutoffTime = Date.now() - thresholdMs;
-
-    for (const file of files) {
-      // Only clean up clipboard-* files with supported extensions
-      if (file.startsWith('clipboard-')) {
-        const ext = path.extname(file).toLowerCase();
-        if (SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS.includes(ext)) {
-          const filePath = path.join(dir, file);
-          try {
-            const stats = await fs.stat(filePath);
-            if (stats.mtimeMs < cutoffTime) {
-              await fs.unlink(filePath);
-            }
-          } catch {
-            // Ignore errors for individual files
-          }
-        }
-      }
-    }
-  } catch {
-    // Ignore errors in cleanup
-  }
-}
-
-/**
- * Check if a file extension is a supported clipboard image format
- * @param extension File extension (with or without dot)
- * @returns true if supported
- */
-export function isSupportedClipboardImageExtension(extension: string): boolean {
-  const ext = extension.startsWith('.')
-    ? extension.toLowerCase()
-    : `.${extension.toLowerCase()}`;
-  return SUPPORTED_CLIPBOARD_IMAGE_EXTENSIONS.includes(ext);
-}

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

@@ -21,7 +21,7 @@ import type {
   AcpConnectionCallbacks,
 } from '../types/connectionTypes.js';
 import { AcpMessageHandler } from './acpMessageHandler.js';
-import { AcpSessionManager, type PromptContent } from './acpSessionManager.js';
+import { AcpSessionManager } from './acpSessionManager.js';
 import * as fs from 'node:fs';
 
 /**
@@ -306,12 +306,12 @@ export class AcpConnection {
   }
 
   /**
-   * Send prompt message with support for multimodal content
+   * Send prompt message
    *
-   * @param prompt - Either a plain text string or array of content items
+   * @param prompt - Prompt content
    * @returns Response
    */
-  async sendPrompt(prompt: string | PromptContent[]): Promise<AcpResponse> {
+  async sendPrompt(prompt: string): Promise<AcpResponse> {
     return this.sessionManager.sendPrompt(
       prompt,
       this.child,

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

@@ -21,13 +21,6 @@ import type { PendingRequest } from '../types/connectionTypes.js';
 import type { ChildProcess } from 'child_process';
 import { isWindows } from '../utils/platform.js';
 
-/**
- * Prompt content types for multimodal messages
- */
-export type PromptContent =
-  | { type: 'text'; text: string }
-  | { type: 'image'; data: string; mimeType: string };
-
 /**
  * ACP Session Manager Class
  * Provides session initialization, authentication, creation, loading, and switching functionality
@@ -220,9 +213,9 @@ export class AcpSessionManager {
   }
 
   /**
-   * Send prompt message with support for multimodal content (text and images)
+   * Send prompt message
    *
-   * @param prompt - Either a plain text string or array of content items
+   * @param prompt - Prompt content
    * @param child - Child process instance
    * @param pendingRequests - Pending requests map
    * @param nextRequestId - Request ID counter
@@ -230,7 +223,7 @@ export class AcpSessionManager {
    * @throws Error when there is no active session
    */
   async sendPrompt(
-    prompt: string | PromptContent[],
+    prompt: string,
     child: ChildProcess | null,
     pendingRequests: Map<number, PendingRequest<unknown>>,
     nextRequestId: { value: number },
@@ -239,35 +232,11 @@ export class AcpSessionManager {
       throw new Error('No active ACP session');
     }
 
-    // Convert string to array format for backward compatibility
-    const promptContent: PromptContent[] =
-      typeof prompt === 'string' ? [{ type: 'text', text: prompt }] : prompt;
-
-    // Debug log to see what we're sending
-    console.log(
-      '[ACP] Sending prompt with content:',
-      JSON.stringify(promptContent, null, 2),
-    );
-    console.log(
-      '[ACP] Content types:',
-      promptContent.map((c) => c.type),
-    );
-    if (promptContent.some((c) => c.type === 'image')) {
-      console.log('[ACP] Message includes images');
-      promptContent.forEach((content, index) => {
-        if (content.type === 'image') {
-          console.log(
-            `[ACP] Image ${index}: mimeType=${content.mimeType}, data length=${content.data.length}`,
-          );
-        }
-      });
-    }
-
     return await this.sendRequest(
       AGENT_METHODS.session_prompt,
       {
         sessionId: this.sessionId,
-        prompt: promptContent,
+        prompt: [{ type: 'text', text: prompt }],
       },
       child,
       pendingRequests,

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

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AcpConnection } from './acpConnection.js';
-import type { PromptContent } from './acpSessionManager.js';
 import type {
   AcpSessionUpdate,
   AcpPermissionRequest,
@@ -216,7 +215,7 @@ export class QwenAgentManager {
    *
    * @param message - Message content
    */
-  async sendMessage(message: string | PromptContent[]): Promise<void> {
+  async sendMessage(message: string): Promise<void> {
     await this.connection.sendPrompt(message);
   }
 

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

@@ -10,14 +10,6 @@ export interface ChatMessage {
   role: 'user' | 'assistant';
   content: string;
   timestamp: number;
-  attachments?: Array<{
-    id: string;
-    name: string;
-    type: string;
-    size: number;
-    data: string;
-    timestamp: number;
-  }>;
 }
 
 export interface PlanEntry {

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

@@ -51,9 +51,6 @@ import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit,
 } from '@qwen-code/qwen-code-core/src/core/tokenLimits.js';
-import type { ImageAttachment } from './utils/imageUtils.js';
-import { formatFileSize, MAX_TOTAL_IMAGE_SIZE } from './utils/imageUtils.js';
-import { usePasteHandler } from './hooks/usePasteHandler.js';
 
 export const App: React.FC = () => {
   const vscode = useVSCode();
@@ -71,7 +68,6 @@ export const App: React.FC = () => {
 
   // UI state
   const [inputText, setInputText] = useState('');
-  const [attachedImages, setAttachedImages] = useState<ImageAttachment[]>([]);
   const [permissionRequest, setPermissionRequest] = useState<{
     options: PermissionOption[];
     toolCall: PermissionToolCall;
@@ -247,54 +243,10 @@ export const App: React.FC = () => {
     completion.query,
   ]);
 
-  // Image handling
-  const handleAddImages = useCallback((newImages: ImageAttachment[]) => {
-    setAttachedImages((prev) => {
-      const currentTotal = prev.reduce((sum, img) => sum + img.size, 0);
-      let runningTotal = currentTotal;
-      const accepted: ImageAttachment[] = [];
-
-      for (const img of newImages) {
-        if (runningTotal + img.size > MAX_TOTAL_IMAGE_SIZE) {
-          console.warn(
-            `Skipping image "${img.name}" – total attachment size would exceed ${formatFileSize(MAX_TOTAL_IMAGE_SIZE)}.`,
-          );
-          continue;
-        }
-        accepted.push(img);
-        runningTotal += img.size;
-      }
-
-      if (accepted.length === 0) {
-        return prev;
-      }
-      return [...prev, ...accepted];
-    });
-  }, []);
-
-  const handleRemoveImage = useCallback((imageId: string) => {
-    setAttachedImages((prev) => prev.filter((img) => img.id !== imageId));
-  }, []);
-
-  const clearImages = useCallback(() => {
-    setAttachedImages([]);
-  }, []);
-
-  // Initialize paste handler
-  const { handlePaste } = usePasteHandler({
-    onImagesAdded: handleAddImages,
-    onError: (error) => {
-      console.error('Paste error:', error);
-      // You can show a toast/notification here if needed
-    },
-  });
-
   // Message submission
   const { handleSubmit: submitMessage } = useMessageSubmit({
     inputText,
     setInputText,
-    attachedImages,
-    clearImages,
     messageHandling,
     fileContext,
     skipAutoActiveContext,
@@ -714,7 +666,6 @@ export const App: React.FC = () => {
                   timestamp={msg.timestamp || 0}
                   onFileClick={handleFileClick}
                   fileContext={msg.fileContext}
-                  attachments={msg.attachments}
                 />
               );
             }
@@ -863,7 +814,6 @@ export const App: React.FC = () => {
           activeSelection={fileContext.activeSelection}
           skipAutoActiveContext={skipAutoActiveContext}
           contextUsage={contextUsage}
-          attachedImages={attachedImages}
           onInputChange={setInputText}
           onCompositionStart={() => setIsComposing(true)}
           onCompositionEnd={() => setIsComposing(false)}
@@ -876,8 +826,6 @@ export const App: React.FC = () => {
           onToggleSkipAutoActiveContext={() =>
             setSkipAutoActiveContext((v) => !v)
           }
-          onPaste={handlePaste}
-          onRemoveImage={handleRemoveImage}
           onShowCommandMenu={async () => {
             if (inputFieldRef.current) {
               inputFieldRef.current.focus();

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

@@ -38,7 +38,7 @@ export class WebViewContent {
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src ${panel.webview.cspSource} data:; script-src ${panel.webview.cspSource}; style-src ${panel.webview.cspSource} 'unsafe-inline';">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src ${panel.webview.cspSource}; script-src ${panel.webview.cspSource}; style-src ${panel.webview.cspSource} 'unsafe-inline';">
   <title>Qwen Code</title>
 </head>
 <body data-extension-uri="${safeExtensionUri}">

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

@@ -1,60 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type React from 'react';
-import type { ImageAttachment } from '../utils/imageUtils.js';
-
-interface ImagePreviewProps {
-  images: ImageAttachment[];
-  onRemove: (id: string) => void;
-}
-
-export const ImagePreview: React.FC<ImagePreviewProps> = ({
-  images,
-  onRemove,
-}) => {
-  if (!images || images.length === 0) {
-    return null;
-  }
-
-  return (
-    <div className="image-preview-container flex gap-2 px-2 pb-2">
-      {images.map((image) => (
-        <div key={image.id} className="image-preview-item relative group">
-          <div className="relative">
-            <img
-              src={image.data}
-              alt={image.name}
-              className="w-14 h-14 object-cover rounded-md border border-gray-500 dark:border-gray-600"
-              title={image.name}
-            />
-            <button
-              type="button"
-              onClick={() => onRemove(image.id)}
-              className="absolute -top-2 -right-2 w-5 h-5 bg-gray-700 dark:bg-gray-600 text-white rounded-full flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity hover:bg-gray-800 dark:hover:bg-gray-500"
-              aria-label={`Remove ${image.name}`}
-            >
-              <svg
-                className="w-3 h-3"
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-                xmlns="http://www.w3.org/2000/svg"
-              >
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={2}
-                  d="M6 18L18 6M6 6l12 12"
-                />
-              </svg>
-            </button>
-          </div>
-        </div>
-      ))}
-    </div>
-  );
-};

packages/vscode-ide-companion/src/webview/components/layout/InputForm.tsx

@@ -22,8 +22,6 @@ import type { CompletionItem } from '../../../types/completionItemTypes.js';
 import { getApprovalModeInfoFromString } from '../../../types/acpTypes.js';
 import type { ApprovalModeValue } from '../../../types/approvalModeValueTypes.js';
 import { ContextIndicator } from './ContextIndicator.js';
-import { ImagePreview } from '../ImagePreview.js';
-import type { ImageAttachment } from '../../utils/imageUtils.js';
 
 interface InputFormProps {
   inputText: string;
@@ -44,7 +42,6 @@ interface InputFormProps {
     usedTokens: number;
     tokenLimit: number;
   } | null;
-  attachedImages?: ImageAttachment[];
   onInputChange: (text: string) => void;
   onCompositionStart: () => void;
   onCompositionEnd: () => void;
@@ -57,8 +54,6 @@ interface InputFormProps {
   onToggleSkipAutoActiveContext: () => void;
   onShowCommandMenu: () => void;
   onAttachContext: () => void;
-  onPaste?: (e: React.ClipboardEvent) => void;
-  onRemoveImage?: (id: string) => void;
   completionIsOpen: boolean;
   completionItems?: CompletionItem[];
   onCompletionSelect?: (item: CompletionItem) => void;
@@ -108,7 +103,6 @@ export const InputForm: React.FC<InputFormProps> = ({
   activeSelection,
   skipAutoActiveContext,
   contextUsage,
-  attachedImages = [],
   onInputChange,
   onCompositionStart,
   onCompositionEnd,
@@ -120,8 +114,6 @@ export const InputForm: React.FC<InputFormProps> = ({
   onToggleSkipAutoActiveContext,
   onShowCommandMenu,
   onAttachContext,
-  onPaste,
-  onRemoveImage,
   completionIsOpen,
   completionItems,
   onCompletionSelect,
@@ -168,7 +160,7 @@ export const InputForm: React.FC<InputFormProps> = ({
           {/* Banner area */}
           <div className="input-banner" />
 
-          <div className="relative flex flex-col z-[1]">
+          <div className="relative flex z-[1]">
             {completionIsOpen &&
               completionItems &&
               completionItems.length > 0 &&
@@ -206,14 +198,8 @@ export const InputForm: React.FC<InputFormProps> = ({
               onCompositionStart={onCompositionStart}
               onCompositionEnd={onCompositionEnd}
               onKeyDown={handleKeyDown}
-              onPaste={onPaste}
               suppressContentEditableWarning
             />
-
-            {/* Image Preview area - shown at the bottom inside the input box */}
-            {attachedImages.length > 0 && onRemoveImage && (
-              <ImagePreview images={attachedImages} onRemove={onRemoveImage} />
-            )}
           </div>
 
           <div className="composer-actions">

packages/vscode-ide-companion/src/webview/components/messages/UserMessage.tsx

@@ -6,7 +6,6 @@
 
 import type React from 'react';
 import { MessageContent } from './MessageContent.js';
-import type { ImageAttachment } from '../../utils/imageUtils.js';
 
 interface FileContext {
   fileName: string;
@@ -20,7 +19,6 @@ interface UserMessageProps {
   timestamp: number;
   onFileClick?: (path: string) => void;
   fileContext?: FileContext;
-  attachments?: ImageAttachment[];
 }
 
 export const UserMessage: React.FC<UserMessageProps> = ({
@@ -28,7 +26,6 @@ export const UserMessage: React.FC<UserMessageProps> = ({
   timestamp: _timestamp,
   onFileClick,
   fileContext,
-  attachments,
 }) => {
   // Generate display text for file context
   const getFileContextDisplay = () => {
@@ -69,24 +66,6 @@ export const UserMessage: React.FC<UserMessageProps> = ({
         />
       </div>
 
-      {/* Display attached images */}
-      {attachments && attachments.length > 0 && (
-        <div className="mt-2 flex flex-wrap gap-2">
-          {attachments.map((attachment) => (
-            <div key={attachment.id} className="relative">
-              <img
-                src={attachment.data}
-                alt={attachment.name}
-                className="max-w-[200px] max-h-[200px] rounded-md border border-gray-300 dark:border-gray-600"
-                style={{
-                  objectFit: 'contain',
-                }}
-              />
-            </div>
-          ))}
-        </div>
-      )}
-
       {/* File context indicator */}
       {fileContextDisplay && (
         <div className="mt-1">

packages/vscode-ide-companion/src/webview/handlers/SessionMessageHandler.ts

@@ -9,11 +9,6 @@ import { BaseMessageHandler } from './BaseMessageHandler.js';
 import type { ChatMessage } from '../../services/qwenAgentManager.js';
 import type { ApprovalModeValue } from '../../types/approvalModeValueTypes.js';
 import { ACP_ERROR_CODES } from '../../constants/acpSchema.js';
-import type { PromptContent } from '../../services/acpSessionManager.js';
-import {
-  cleanupOldClipboardImages,
-  saveBase64ImageSync,
-} from '@qwen-code/qwen-code-core/src/utils/clipboardImageStorage.js';
 
 const AUTH_REQUIRED_CODE_PATTERN = `(code: ${ACP_ERROR_CODES.AUTH_REQUIRED})`;
 
@@ -50,51 +45,29 @@ export class SessionMessageHandler extends BaseMessageHandler {
   }
 
   async handle(message: { type: string; data?: unknown }): Promise<void> {
-    type SendMessagePayload = {
-      text?: string;
-      context?: Array<{
-        type: string;
-        name: string;
-        value: string;
-        startLine?: number;
-        endLine?: number;
-      }>;
-      fileContext?: {
-        fileName: string;
-        filePath: string;
-        startLine?: number;
-        endLine?: number;
-      };
-      attachments?: Array<{
-        id: string;
-        name: string;
-        type: string;
-        size: number;
-        data: string;
-        timestamp: number;
-      }>;
-    };
-
-    type MessageData = {
-      text?: string;
-      context?: SendMessagePayload['context'];
-      fileContext?: SendMessagePayload['fileContext'];
-      attachments?: SendMessagePayload['attachments'];
-      sessionId?: string;
-      cursor?: number;
-      size?: number;
-      tag?: string;
-    };
-
-    const data = message.data as MessageData | undefined;
+    const data = message.data as Record<string, unknown> | undefined;
 
     switch (message.type) {
       case 'sendMessage':
         await this.handleSendMessage(
-          data?.text || '',
-          data?.context,
-          data?.fileContext,
-          data?.attachments,
+          (data?.text as string) || '',
+          data?.context as
+            | Array<{
+                type: string;
+                name: string;
+                value: string;
+                startLine?: number;
+                endLine?: number;
+              }>
+            | undefined,
+          data?.fileContext as
+            | {
+                fileName: string;
+                filePath: string;
+                startLine?: number;
+                endLine?: number;
+              }
+            | undefined,
         );
         break;
 
@@ -103,19 +76,22 @@ export class SessionMessageHandler extends BaseMessageHandler {
         break;
 
       case 'switchQwenSession':
-        await this.handleSwitchQwenSession(data?.sessionId || '');
+        await this.handleSwitchQwenSession((data?.sessionId as string) || '');
         break;
 
       case 'getQwenSessions':
-        await this.handleGetQwenSessions(data?.cursor, data?.size);
+        await this.handleGetQwenSessions(
+          (data?.cursor as number | undefined) ?? undefined,
+          (data?.size as number | undefined) ?? undefined,
+        );
         break;
 
       case 'saveSession':
-        await this.handleSaveSession(data?.tag || '');
+        await this.handleSaveSession((data?.tag as string) || '');
         break;
 
       case 'resumeSession':
-        await this.handleResumeSession(data?.sessionId || '');
+        await this.handleResumeSession((data?.sessionId as string) || '');
         break;
 
       case 'openNewChatTab':
@@ -158,34 +134,6 @@ export class SessionMessageHandler extends BaseMessageHandler {
     }
   }
 
-  /**
-   * Save base64 image to a temporary file
-   * Uses the shared clipboard image storage utility from core package.
-   * @param base64Data The base64 encoded image data (with or without data URL prefix)
-   * @param fileName Original filename
-   * @returns The relative path to the saved file or null if failed
-   */
-  private saveImageToFile(base64Data: string, fileName: string): string | null {
-    // Get workspace folder
-    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
-    if (!workspaceFolder) {
-      console.error('[SessionMessageHandler] No workspace folder found');
-      return null;
-    }
-
-    const relativePath = saveBase64ImageSync(
-      base64Data,
-      fileName,
-      workspaceFolder.uri.fsPath,
-    );
-
-    if (relativePath) {
-      console.log('[SessionMessageHandler] Saved image to:', relativePath);
-    }
-
-    return relativePath;
-  }
-
   /**
    * Get current stream content
    */
@@ -287,23 +235,8 @@ export class SessionMessageHandler extends BaseMessageHandler {
       startLine?: number;
       endLine?: number;
     },
-    attachments?: Array<{
-      id: string;
-      name: string;
-      type: string;
-      size: number;
-      data: string;
-      timestamp: number;
-    }>,
   ): Promise<void> {
     console.log('[SessionMessageHandler] handleSendMessage called with:', text);
-    if (attachments && attachments.length > 0) {
-      console.log(
-        '[SessionMessageHandler] Message includes',
-        attachments.length,
-        'image attachments',
-      );
-    }
 
     // Format message with file context if present
     let formattedText = text;
@@ -320,100 +253,6 @@ export class SessionMessageHandler extends BaseMessageHandler {
       formattedText = `${contextParts}\n\n${text}`;
     }
 
-    if (!formattedText && (!attachments || attachments.length === 0)) {
-      this.sendToWebView({
-        type: 'error',
-        data: { message: 'Message is empty.' },
-      });
-      return;
-    }
-
-    // Build prompt content
-    let promptContent: PromptContent[] = [];
-
-    // Add text content (with context if present)
-    if (formattedText) {
-      promptContent.push({
-        type: 'text',
-        text: formattedText,
-      });
-    }
-
-    // Add image attachments - save to files and reference them
-    if (attachments && attachments.length > 0) {
-      console.log(
-        '[SessionMessageHandler] Processing attachments - saving to files',
-      );
-
-      // Save images as files and add references to the text
-      const imageReferences: string[] = [];
-
-      for (const attachment of attachments) {
-        console.log('[SessionMessageHandler] Processing attachment:', {
-          id: attachment.id,
-          name: attachment.name,
-          type: attachment.type,
-          dataLength: attachment.data.length,
-        });
-
-        // Save image to file (sync operation using shared utility)
-        const imagePath = this.saveImageToFile(
-          attachment.data,
-          attachment.name,
-        );
-        if (imagePath) {
-          // Add file reference to the message (like CLI does with @path)
-          imageReferences.push(`@${imagePath}`);
-          console.log(
-            '[SessionMessageHandler] Added image reference:',
-            `@${imagePath}`,
-          );
-        } else {
-          console.warn(
-            '[SessionMessageHandler] Failed to save image:',
-            attachment.name,
-          );
-        }
-      }
-
-      const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
-      if (workspaceFolder) {
-        cleanupOldClipboardImages(workspaceFolder.uri.fsPath).catch((error) => {
-          console.warn(
-            '[SessionMessageHandler] Failed to cleanup clipboard images:',
-            error,
-          );
-        });
-      }
-
-      // Add image references to the text
-      if (imageReferences.length > 0) {
-        const imageText = imageReferences.join(' ');
-        // Update the formatted text with image references
-        const updatedText = formattedText
-          ? `${formattedText}\n\n${imageText}`
-          : imageText;
-
-        // Replace the prompt content with updated text
-        promptContent = [
-          {
-            type: 'text',
-            text: updatedText,
-          },
-        ];
-
-        console.log(
-          '[SessionMessageHandler] Updated text with image references:',
-          updatedText,
-        );
-      }
-    }
-
-    console.log('[SessionMessageHandler] Final promptContent:', {
-      count: promptContent.length,
-      types: promptContent.map((c) => c.type),
-    });
-
     // Ensure we have an active conversation
     if (!this.currentConversationId) {
       console.log(
@@ -482,19 +321,17 @@ export class SessionMessageHandler extends BaseMessageHandler {
       role: 'user',
       content: text,
       timestamp: Date.now(),
-      ...(attachments && attachments.length > 0 ? { attachments } : {}),
     };
 
-    // Store the original message with just text
     await this.conversationStore.addMessage(
       this.currentConversationId,
       userMessage,
     );
 
-    // Send to WebView with file context and attachments
+    // Send to WebView
     this.sendToWebView({
       type: 'message',
-      data: { ...userMessage, fileContext, attachments },
+      data: { ...userMessage, fileContext },
     });
 
     // Check if agent is connected
@@ -542,8 +379,7 @@ export class SessionMessageHandler extends BaseMessageHandler {
         data: { timestamp: Date.now() },
       });
 
-      // Send multimodal content instead of plain text
-      await this.agentManager.sendMessage(promptContent);
+      await this.agentManager.sendMessage(formattedText);
 
       // Save assistant message
       if (this.currentStreamContent && this.currentConversationId) {
@@ -736,13 +572,7 @@ export class SessionMessageHandler extends BaseMessageHandler {
       }
 
       // Get session details (includes cwd and filePath when using ACP)
-      type SessionDetails = {
-        id?: string;
-        sessionId?: string;
-        cwd?: string;
-        [key: string]: unknown;
-      };
-      let sessionDetails: SessionDetails | null = null;
+      let sessionDetails: Record<string, unknown> | null = null;
       try {
         const allSessions = await this.agentManager.getSessionList();
         sessionDetails =
@@ -771,7 +601,7 @@ export class SessionMessageHandler extends BaseMessageHandler {
 
         const loadResponse = await this.agentManager.loadSessionViaAcp(
           sessionId,
-          sessionDetails?.cwd,
+          (sessionDetails?.cwd as string | undefined) || undefined,
         );
         console.log(
           '[SessionMessageHandler] session/load succeeded (per ACP spec result is null; actual history comes via session/update):',

packages/vscode-ide-companion/src/webview/hooks/message/useMessageHandling.ts

@@ -5,7 +5,6 @@
  */
 
 import { useState, useRef, useCallback } from 'react';
-import type { ImageAttachment } from '../../utils/imageUtils.js';
 
 export interface TextMessage {
   role: 'user' | 'assistant' | 'thinking';
@@ -17,7 +16,6 @@ export interface TextMessage {
     startLine?: number;
     endLine?: number;
   };
-  attachments?: ImageAttachment[];
 }
 
 /**

packages/vscode-ide-companion/src/webview/hooks/useMessageSubmit.ts

@@ -7,14 +7,11 @@
 import { useCallback } from 'react';
 import type { VSCodeAPI } from './useVSCode.js';
 import { getRandomLoadingMessage } from '../../constants/loadingMessages.js';
-import type { ImageAttachment } from '../utils/imageUtils.js';
 
 interface UseMessageSubmitProps {
   vscode: VSCodeAPI;
   inputText: string;
   setInputText: (text: string) => void;
-  attachedImages?: ImageAttachment[];
-  clearImages?: () => void;
   inputFieldRef: React.RefObject<HTMLDivElement>;
   isStreaming: boolean;
   isWaitingForResponse: boolean;
@@ -42,8 +39,6 @@ export const useMessageSubmit = ({
   vscode,
   inputText,
   setInputText,
-  attachedImages = [],
-  clearImages,
   inputFieldRef,
   isStreaming,
   isWaitingForResponse,
@@ -147,7 +142,6 @@ export const useMessageSubmit = ({
           text: inputText,
           context: context.length > 0 ? context : undefined,
           fileContext: fileContextForMessage,
-          attachments: attachedImages.length > 0 ? attachedImages : undefined,
         },
       });
 
@@ -159,15 +153,9 @@ export const useMessageSubmit = ({
         inputFieldRef.current.setAttribute('data-empty', 'true');
       }
       fileContext.clearFileReferences();
-      // Clear attached images after sending
-      if (clearImages) {
-        clearImages();
-      }
     },
     [
       inputText,
-      attachedImages,
-      clearImages,
       isStreaming,
       setInputText,
       inputFieldRef,

packages/vscode-ide-companion/src/webview/hooks/usePasteHandler.ts

@@ -1,124 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useCallback, useRef } from 'react';
-import {
-  createImageAttachment,
-  generatePastedImageName,
-  isSupportedImage,
-  isWithinSizeLimit,
-  formatFileSize,
-  type ImageAttachment,
-} from '../utils/imageUtils.js';
-
-interface UsePasteHandlerOptions {
-  onImagesAdded?: (images: ImageAttachment[]) => void;
-  onTextPaste?: (text: string) => void;
-  onError?: (error: string) => void;
-}
-
-export function usePasteHandler({
-  onImagesAdded,
-  onTextPaste,
-  onError,
-}: UsePasteHandlerOptions) {
-  const processingRef = useRef(false);
-
-  const handlePaste = useCallback(
-    async (event: React.ClipboardEvent | ClipboardEvent) => {
-      // Prevent duplicate processing
-      if (processingRef.current) {
-        return;
-      }
-
-      const clipboardData = event.clipboardData;
-      if (!clipboardData) {
-        return;
-      }
-
-      const files = clipboardData.files;
-      const hasFiles = files && files.length > 0;
-      const imageFiles = hasFiles
-        ? Array.from(files).filter((file) => file.type.startsWith('image/'))
-        : [];
-
-      // Check if there are image files in the clipboard
-      if (imageFiles.length > 0) {
-        processingRef.current = true;
-        event.preventDefault();
-        event.stopPropagation();
-
-        const imageAttachments: ImageAttachment[] = [];
-        const errors: string[] = [];
-
-        try {
-          for (const file of imageFiles) {
-            // Check if it's a supported image type
-            if (!isSupportedImage(file)) {
-              errors.push(`Unsupported image type: ${file.type}`);
-              continue;
-            }
-
-            // Check file size
-            if (!isWithinSizeLimit(file)) {
-              errors.push(
-                `Image "${file.name || 'pasted image'}" is too large (${formatFileSize(
-                  file.size,
-                )}). Maximum size is 10MB.`,
-              );
-              continue;
-            }
-
-            try {
-              // If the file doesn't have a name (clipboard paste), generate one
-              const imageFile =
-                file.name && file.name !== 'image.png'
-                  ? file
-                  : new File([file], generatePastedImageName(file.type), {
-                      type: file.type,
-                    });
-
-              const attachment = await createImageAttachment(imageFile);
-              if (attachment) {
-                imageAttachments.push(attachment);
-              }
-            } catch (error) {
-              console.error('Failed to process pasted image:', error);
-              errors.push(
-                `Failed to process image "${file.name || 'pasted image'}"`,
-              );
-            }
-          }
-
-          // Report errors if any
-          if (errors.length > 0 && onError) {
-            onError(errors.join('\n'));
-          }
-
-          // Add successfully processed images
-          if (imageAttachments.length > 0 && onImagesAdded) {
-            onImagesAdded(imageAttachments);
-          }
-        } finally {
-          processingRef.current = false;
-        }
-
-        return;
-      }
-
-      // Handle text paste
-      const text = clipboardData.getData('text/plain');
-      if (text && onTextPaste) {
-        // Let the default paste behavior handle text
-        // unless we want to process it specially
-        onTextPaste(text);
-      }
-    },
-    [onImagesAdded, onTextPaste, onError],
-  );
-
-  return { handlePaste };
-}

packages/vscode-ide-companion/src/webview/hooks/useWebViewMessages.ts

@@ -358,20 +358,6 @@ export const useWebViewMessages = ({
             role?: 'user' | 'assistant' | 'thinking';
             content?: string;
             timestamp?: number;
-            fileContext?: {
-              fileName: string;
-              filePath: string;
-              startLine?: number;
-              endLine?: number;
-            };
-            attachments?: Array<{
-              id: string;
-              name: string;
-              type: string;
-              size: number;
-              data: string;
-              timestamp: number;
-            }>;
           };
           handlers.messageHandling.addMessage(
             msg as unknown as Parameters<

packages/vscode-ide-companion/src/webview/utils/imageUtils.test.ts

@@ -1,163 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { beforeAll, describe, it, expect } from 'vitest';
-import { Buffer } from 'node:buffer';
-
-// Polyfill browser APIs for Node test environment
-const g = globalThis as typeof globalThis & {
-  FileReader?: typeof FileReader;
-  atob?: typeof atob;
-  File?: typeof File;
-};
-
-if (!g.atob) {
-  g.atob = (b64: string) => Buffer.from(b64, 'base64').toString('binary');
-}
-
-if (!g.FileReader) {
-  class MockFileReader {
-    result: string | ArrayBuffer | null = null;
-    onload: ((ev: ProgressEvent<FileReader>) => void) | null = null;
-    onerror: ((ev: unknown) => void) | null = null;
-
-    readAsDataURL(blob: Blob) {
-      blob
-        .arrayBuffer()
-        .then((buf) => {
-          const base64 = Buffer.from(buf).toString('base64');
-          const mime =
-            (blob as { type?: string }).type || 'application/octet-stream';
-          this.result = `data:${mime};base64,${base64}`;
-          this.onload?.({} as ProgressEvent<FileReader>);
-        })
-        .catch((err) => {
-          this.onerror?.(err);
-        });
-    }
-  }
-  g.FileReader = MockFileReader as unknown as typeof FileReader;
-}
-
-if (!g.File) {
-  class MockFile extends Blob {
-    name: string;
-    lastModified: number;
-    constructor(
-      bits: BlobPart[],
-      name: string,
-      options?: BlobPropertyBag & { lastModified?: number },
-    ) {
-      super(bits, options);
-      this.name = name;
-      this.lastModified = options?.lastModified ?? Date.now();
-    }
-  }
-  g.File = MockFile as unknown as typeof File;
-}
-
-let fileToBase64: typeof import('./imageUtils.js').fileToBase64;
-let isSupportedImage: typeof import('./imageUtils.js').isSupportedImage;
-let isWithinSizeLimit: typeof import('./imageUtils.js').isWithinSizeLimit;
-let formatFileSize: typeof import('./imageUtils.js').formatFileSize;
-let generateImageId: typeof import('./imageUtils.js').generateImageId;
-let getExtensionFromMimeType: typeof import('./imageUtils.js').getExtensionFromMimeType;
-
-beforeAll(async () => {
-  const mod = await import('./imageUtils.js');
-  fileToBase64 = mod.fileToBase64;
-  isSupportedImage = mod.isSupportedImage;
-  isWithinSizeLimit = mod.isWithinSizeLimit;
-  formatFileSize = mod.formatFileSize;
-  generateImageId = mod.generateImageId;
-  getExtensionFromMimeType = mod.getExtensionFromMimeType;
-});
-
-describe('Image Utils', () => {
-  describe('isSupportedImage', () => {
-    it('should accept supported image types', () => {
-      const pngFile = new File([''], 'test.png', { type: 'image/png' });
-      const jpegFile = new File([''], 'test.jpg', { type: 'image/jpeg' });
-      const gifFile = new File([''], 'test.gif', { type: 'image/gif' });
-
-      expect(isSupportedImage(pngFile)).toBe(true);
-      expect(isSupportedImage(jpegFile)).toBe(true);
-      expect(isSupportedImage(gifFile)).toBe(true);
-    });
-
-    it('should reject unsupported file types', () => {
-      const textFile = new File([''], 'test.txt', { type: 'text/plain' });
-      const pdfFile = new File([''], 'test.pdf', { type: 'application/pdf' });
-
-      expect(isSupportedImage(textFile)).toBe(false);
-      expect(isSupportedImage(pdfFile)).toBe(false);
-    });
-  });
-
-  describe('isWithinSizeLimit', () => {
-    it('should accept files under 10MB', () => {
-      const smallFile = new File(['a'.repeat(1024 * 1024)], 'small.png', {
-        type: 'image/png',
-      });
-      expect(isWithinSizeLimit(smallFile)).toBe(true);
-    });
-
-    it('should reject files over 10MB', () => {
-      // Create a mock file with size property
-      const largeFile = {
-        size: 11 * 1024 * 1024, // 11MB
-      } as File;
-      expect(isWithinSizeLimit(largeFile)).toBe(false);
-    });
-  });
-
-  describe('formatFileSize', () => {
-    it('should format bytes correctly', () => {
-      expect(formatFileSize(0)).toBe('0 B');
-      expect(formatFileSize(512)).toBe('512 B');
-      expect(formatFileSize(1024)).toBe('1 KB');
-      expect(formatFileSize(1536)).toBe('1.5 KB');
-      expect(formatFileSize(1024 * 1024)).toBe('1 MB');
-      expect(formatFileSize(1.5 * 1024 * 1024)).toBe('1.5 MB');
-    });
-  });
-
-  describe('generateImageId', () => {
-    it('should generate unique IDs', () => {
-      const id1 = generateImageId();
-      const id2 = generateImageId();
-
-      expect(id1).toMatch(/^img_\d+_[a-z0-9]+$/);
-      expect(id2).toMatch(/^img_\d+_[a-z0-9]+$/);
-      expect(id1).not.toBe(id2);
-    });
-  });
-
-  describe('getExtensionFromMimeType', () => {
-    it('should return correct extensions', () => {
-      expect(getExtensionFromMimeType('image/png')).toBe('.png');
-      expect(getExtensionFromMimeType('image/jpeg')).toBe('.jpg');
-      expect(getExtensionFromMimeType('image/gif')).toBe('.gif');
-      expect(getExtensionFromMimeType('image/webp')).toBe('.webp');
-      expect(getExtensionFromMimeType('unknown/type')).toBe('.png'); // default
-    });
-  });
-
-  describe('fileToBase64', () => {
-    it('should convert file to base64', async () => {
-      const content = 'test content';
-      const file = new File([content], 'test.txt', { type: 'text/plain' });
-
-      const base64 = await fileToBase64(file);
-      expect(base64).toMatch(/^data:text\/plain;base64,/);
-
-      // Decode and verify content
-      const base64Content = base64.split(',')[1];
-      const decoded = atob(base64Content);
-      expect(decoded).toBe(content);
-    });
-  });
-});

packages/vscode-ide-companion/src/webview/utils/imageUtils.ts

@@ -1,155 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// Supported image MIME types
-export const SUPPORTED_IMAGE_TYPES = [
-  'image/png',
-  'image/jpeg',
-  'image/jpg',
-  'image/gif',
-  'image/webp',
-  'image/bmp',
-];
-
-// Maximum file size in bytes (10MB)
-export const MAX_IMAGE_SIZE = 10 * 1024 * 1024;
-// Maximum total size for all images in a single message (20MB)
-export const MAX_TOTAL_IMAGE_SIZE = 20 * 1024 * 1024;
-
-export interface ImageAttachment {
-  id: string;
-  name: string;
-  type: string;
-  size: number;
-  data: string; // base64 encoded
-  timestamp: number;
-}
-
-/**
- * Convert a File or Blob to base64 string
- */
-export async function fileToBase64(file: File | Blob): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      const result = reader.result as string;
-      resolve(result);
-    };
-    reader.onerror = reject;
-    reader.readAsDataURL(file);
-  });
-}
-
-/**
- * Check if a file is a supported image type
- */
-export function isSupportedImage(file: File): boolean {
-  return SUPPORTED_IMAGE_TYPES.includes(file.type);
-}
-
-/**
- * Check if a file size is within limits
- */
-export function isWithinSizeLimit(file: File): boolean {
-  return file.size <= MAX_IMAGE_SIZE;
-}
-
-/**
- * Generate a unique ID for an image attachment
- */
-export function generateImageId(): string {
-  return `img_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-}
-
-/**
- * Get a human-readable file size
- */
-export function formatFileSize(bytes: number): string {
-  if (bytes === 0) {
-    return '0 B';
-  }
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
-
-/**
- * Extract image dimensions from base64 string
- */
-export async function getImageDimensions(
-  base64: string,
-): Promise<{ width: number; height: number }> {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    img.onload = () => {
-      resolve({ width: img.width, height: img.height });
-    };
-    img.onerror = reject;
-    img.src = base64;
-  });
-}
-
-/**
- * Create an ImageAttachment from a File
- */
-export async function createImageAttachment(
-  file: File,
-): Promise<ImageAttachment | null> {
-  if (!isSupportedImage(file)) {
-    console.warn('Unsupported image type:', file.type);
-    return null;
-  }
-
-  if (!isWithinSizeLimit(file)) {
-    console.warn('Image file too large:', formatFileSize(file.size));
-    return null;
-  }
-
-  try {
-    const base64Data = await fileToBase64(file);
-    return {
-      id: generateImageId(),
-      name: file.name || `image_${Date.now()}`,
-      type: file.type,
-      size: file.size,
-      data: base64Data,
-      timestamp: Date.now(),
-    };
-  } catch (error) {
-    console.error('Failed to create image attachment:', error);
-    return null;
-  }
-}
-
-/**
- * Get extension from MIME type
- */
-export function getExtensionFromMimeType(mimeType: string): string {
-  const mimeMap: Record<string, string> = {
-    'image/png': '.png',
-    'image/jpeg': '.jpg',
-    'image/jpg': '.jpg',
-    'image/gif': '.gif',
-    'image/webp': '.webp',
-    'image/bmp': '.bmp',
-    'image/svg+xml': '.svg',
-  };
-  return mimeMap[mimeType] || '.png';
-}
-
-/**
- * Generate a clean filename for pasted images
- */
-export function generatePastedImageName(mimeType: string): string {
-  const now = new Date();
-  const timeStr = `${now.getHours().toString().padStart(2, '0')}${now
-    .getMinutes()
-    .toString()
-    .padStart(2, '0')}${now.getSeconds().toString().padStart(2, '0')}`;
-  const ext = getExtensionFromMimeType(mimeType);
-  return `pasted_image_${timeStr}${ext}`;
-}