feat(vscode-ide-companion): cherry-pick ACP compatibility improvements from PR #2195

- Add extractSessionListItems() utility for robust ACP response parsing
- Refactor getSessionList() and getSessionListPaged() to use the new utility
- Add openNewChatTabCommand to create new session when opening chat tab
- Add comprehensive test coverage for session list extraction

Co-authored-by: ZZAoYe <zzbuaoye@gmail.com>

Author: yiliang114

packages/vscode-ide-companion/package.json

@@ -28,14 +28,7 @@
     "ide companion"
   ],
   "activationEvents": [
-    "onStartupFinished",
-    "onView:qwenCode.chatView.panel",
-    "onView:qwenCode.chatView.secondary",
-    "onView:qwenCode.chatView.sidebar",
-    "onCommand:qwen-code.openChat",
-    "onCommand:qwen-code.focusChat",
-    "onCommand:qwen-code.newConversation",
-    "onCommand:qwen-code.showLogs"
+    "onStartupFinished"
   ],
   "contributes": {
     "jsonValidation": [

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

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as vscode from 'vscode';
+import { openNewChatTabCommand, registerNewCommands } from './index.js';
+
+vi.mock('vscode', () => ({
+  commands: {
+    registerCommand: vi.fn(
+      (_command: string, _handler: (...args: unknown[]) => unknown) => ({
+        dispose: vi.fn(),
+      }),
+    ),
+  },
+  workspace: {
+    workspaceFolders: [],
+  },
+  window: {
+    showErrorMessage: vi.fn(),
+    showInformationMessage: vi.fn(),
+    showWarningMessage: vi.fn(),
+  },
+  Uri: {
+    joinPath: vi.fn(),
+  },
+}));
+
+describe('registerNewCommands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('creates a fresh session when opening a new chat tab', async () => {
+    const fakeProvider = {
+      show: vi.fn().mockResolvedValue(undefined),
+      createNewSession: vi.fn().mockResolvedValue(undefined),
+      forceReLogin: vi.fn().mockResolvedValue(undefined),
+    };
+
+    registerNewCommands(
+      { subscriptions: [] } as unknown as vscode.ExtensionContext,
+      vi.fn(),
+      {} as never,
+      () => [],
+      () => fakeProvider as never,
+    );
+
+    const commandCall = vi
+      .mocked(vscode.commands.registerCommand)
+      .mock.calls.find(([command]) => command === openNewChatTabCommand);
+
+    expect(commandCall).toBeDefined();
+
+    const handler = commandCall?.[1] as (() => Promise<void>) | undefined;
+    expect(handler).toBeDefined();
+
+    await handler?.();
+
+    expect(fakeProvider.show).toHaveBeenCalledTimes(1);
+    expect(fakeProvider.createNewSession).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -87,6 +87,7 @@ export function registerNewCommands(
     vscode.commands.registerCommand(openNewChatTabCommand, async () => {
       const provider = createWebViewProvider();
       await provider.show();
+      await provider.createNewSession();
     }),
   );
 

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

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import {
+  extractSessionListItems,
+  QwenAgentManager,
+} from './qwenAgentManager.js';
+
+vi.mock('vscode', () => ({
+  window: {
+    showInformationMessage: vi.fn(),
+    showWarningMessage: vi.fn(),
+    showErrorMessage: vi.fn(),
+  },
+}));
+
+describe('extractSessionListItems', () => {
+  it('reads ACP session arrays from the sessions field', () => {
+    const items = extractSessionListItems({
+      sessions: [{ sessionId: 'session-1' }],
+    });
+
+    expect(items).toEqual([{ sessionId: 'session-1' }]);
+  });
+
+  it('reads ACP session arrays from the legacy items field', () => {
+    const items = extractSessionListItems({
+      items: [{ sessionId: 'session-2' }],
+    });
+
+    expect(items).toEqual([{ sessionId: 'session-2' }]);
+  });
+
+  it('returns empty array for invalid responses', () => {
+    expect(extractSessionListItems(null)).toEqual([]);
+    expect(extractSessionListItems(undefined)).toEqual([]);
+    expect(extractSessionListItems('string')).toEqual([]);
+    expect(extractSessionListItems({})).toEqual([]);
+    expect(extractSessionListItems({ sessions: 'not-array' })).toEqual([]);
+  });
+
+  it('prefers sessions over items when both exist', () => {
+    const items = extractSessionListItems({
+      sessions: [{ sessionId: 'from-sessions' }],
+      items: [{ sessionId: 'from-items' }],
+    });
+
+    expect(items).toEqual([{ sessionId: 'from-sessions' }]);
+  });
+});
+
+describe('QwenAgentManager session list compatibility', () => {
+  it('maps paged ACP session lists returned via items', async () => {
+    const manager = new QwenAgentManager();
+    const listSessions = vi.fn().mockResolvedValue({
+      items: [
+        {
+          sessionId: 'session-3',
+          prompt: 'Fix sidebar history',
+          mtime: 1772114825468.5825,
+          cwd: '/workspace/qwen-code',
+        },
+      ],
+    });
+
+    (
+      manager as unknown as {
+        connection: { listSessions: typeof listSessions };
+      }
+    ).connection = { listSessions };
+
+    const page = await manager.getSessionListPaged({ size: 20 });
+
+    expect(listSessions).toHaveBeenCalledWith({ size: 20 });
+    expect(page).toEqual({
+      sessions: [
+        {
+          id: 'session-3',
+          sessionId: 'session-3',
+          title: 'Fix sidebar history',
+          name: 'Fix sidebar history',
+          startTime: undefined,
+          lastUpdated: 1772114825468.5825,
+          messageCount: 0,
+          projectHash: undefined,
+          filePath: undefined,
+          cwd: '/workspace/qwen-code',
+        },
+      ],
+      nextCursor: undefined,
+      hasMore: false,
+    });
+  });
+});

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

@@ -40,6 +40,36 @@ import { handleAuthenticateUpdate } from '../utils/authNotificationHandler.js';
 
 export type { ChatMessage, PlanEntry, ToolCallUpdateData };
 
+/**
+ * Extract session list items from ACP response.
+ * Handles both 'sessions' (new) and 'items' (legacy) response shapes.
+ * @param response - The ACP session/list response
+ * @returns Array of session items, or empty array if invalid
+ */
+export function extractSessionListItems(
+  response: unknown,
+): Array<Record<string, unknown>> {
+  if (!response || typeof response !== 'object') {
+    return [];
+  }
+
+  const payload = response as {
+    sessions?: unknown;
+    items?: unknown;
+  };
+
+  // Prefer 'sessions' field, fall back to 'items' for backwards compatibility
+  if (Array.isArray(payload.sessions)) {
+    return payload.sessions as Array<Record<string, unknown>>;
+  }
+
+  if (Array.isArray(payload.items)) {
+    return payload.items as Array<Record<string, unknown>>;
+  }
+
+  return [];
+}
+
 /**
  * Qwen Agent Manager
  *
@@ -413,14 +443,7 @@ export class QwenAgentManager {
       console.log('[QwenAgentManager] ACP session list response:', response);
 
       const res: unknown = response;
-      let items: Array<Record<string, unknown>> = [];
-
-      if (res && typeof res === 'object' && 'sessions' in res) {
-        const sessionsValue = (res as { sessions?: unknown }).sessions;
-        items = Array.isArray(sessionsValue)
-          ? (sessionsValue as Array<Record<string, unknown>>)
-          : [];
-      }
+      const items = extractSessionListItems(res);
 
       console.log(
         '[QwenAgentManager] Sessions retrieved via ACP:',
@@ -514,14 +537,7 @@ export class QwenAgentManager {
         ...(cursor !== undefined ? { cursor } : {}),
       });
       const res: unknown = response;
-      let items: Array<Record<string, unknown>> = [];
-
-      if (res && typeof res === 'object' && 'sessions' in res) {
-        const sessionsValue = (res as { sessions?: unknown }).sessions;
-        items = Array.isArray(sessionsValue)
-          ? (sessionsValue as Array<Record<string, unknown>>)
-          : [];
-      }
+      const items = extractSessionListItems(res);
 
       const mapped = items.map((item) => ({
         id: item.sessionId || item.id,