Merge remote-tracking branch 'origin/chore-unskip-e2e-use-mcp-tool' into chore-unskip-e2e-subtasks

Author: roomote[bot]

apps/vscode-e2e/AGENTS.md

@@ -137,6 +137,13 @@ Background API calls from the extension (usage collection, initialization) hit a
 
 Some suites can't redirect their provider through aimock. These suites patch `globalThis.fetch` directly — the OpenAI SDK resolves `fetch` at API client construction time (which happens lazily at task start), so installing the interceptor before `api.startNewTask()` is sufficient. Installing it before `api.setConfiguration()` (as done below) is the conservative, recommended order.
 
+Keep fetch-interceptor suites hermetic across test cases:
+
+- reset in-memory request/event capture in `setup()` or allocate a fresh per-test buffer instead of reusing shared mutable state implicitly
+- scope request-shape assertions to the current probe or test tag only; do not pull in older requests just because they contain tool outputs
+- assume late async requests from the prior task can still arrive after a shared array/map was cleared, so tags or other per-probe identity should be the source of truth
+- when changing persisted provider/model settings in tests, use the path that clears prior provider fields instead of partial mutation
+
 ### Z.ai GLM (`suite/providers/zai.test.ts`)
 
 Z.ai doesn't expose a user-configurable base URL (it uses a fixed set of regional endpoints), so we deliberately avoided adding a hidden test-only override to the schema. The suite instead patches `globalThis.fetch` to intercept requests to `api.z.ai` and return a crafted OpenAI-compatible SSE response.
@@ -153,6 +160,39 @@ ZAI_API_KEY=<key> TEST_FILE=zai.test pnpm --filter @roo-code/vscode-e2e test:ci
 
 When adding a new test to this suite, add a matching fixture to the `installZAiFetchInterceptor` call in `suiteSetup`. Use a short unique prefix (e.g. `"zai-glm-e2e-mytest:"`) that won't appear in `<environment_details>`.
 
+### xAI Grok (`suite/providers/xai.test.ts`)
+
+xAI uses the **Responses API** (`POST https://api.x.ai/v1/responses`), which is not OpenAI-compatible. aimock can't intercept it. The suite instead patches `globalThis.fetch` to intercept requests to that endpoint. By default it replays hand-crafted SSE events; when a local `fixtures/xai.json` recording exists, it can replay recorded real-API SSE events for reference.
+
+The local `fixtures/xai.json` file is gitignored. It keeps an empty top-level `fixtures` array so aimock can scan the directory without warnings. xAI recordings live under `xaiResponses`, which maps each model ID to `{ readCallId, turn1, turn2 }`:
+
+- **`turn1`** — raw SSE events from the real API for the first API call (should contain a `read_file` function call)
+- **`readCallId`** — the `call_id` extracted from turn 1's `response.output_item.done` event; used to match the turn 2 request
+- **`turn2`** — raw SSE events for the second API call (should contain an `attempt_completion` call with the correct result text)
+
+Having real-API events in the fixture guarantees:
+
+1. The SSE format expected by the stream processor is correct.
+2. The `attempt_completion.result` field contains the actual marker value (not an empty string).
+
+**Recording** (populate or refresh the fixture from the real xAI API):
+
+```sh
+XAI_API_KEY=<key> XAI_RECORD=true TEST_FILE=providers/xai.test.js pnpm --filter @roo-code/vscode-e2e test:run
+```
+
+This routes all xAI requests through the real API, captures the SSE events per turn, and writes the local gitignored `fixtures/xai.json` on teardown.
+
+**Verifying the recorded fixture in mock mode** (no API key needed):
+
+```sh
+TEST_FILE=xai.test pnpm --filter @roo-code/vscode-e2e test:ci:mock
+```
+
+When no local recording exists for a model, the interceptor falls back to hand-crafted SSE events (using a hardcoded `readCallId`). CI should use this fallback so the suite remains deterministic and does not depend on large raw provider recordings.
+
+When adding a new test to this suite, update the hand-crafted interceptor response unless the behavior specifically needs a real xAI SSE recording for local debugging. Use a short unique probe tag (e.g. `"xai-e2e:grok-4.20"`) that won't appear in `<environment_details>`.
+
 ### DeepSeek V4 (`suite/providers/deepseek-v4.test.ts`)
 
 DeepSeek exposes `deepSeekBaseUrl`, so the suite redirects the OpenAI-compatible DeepSeek client through aimock with `deepSeekBaseUrl: ${AIMOCK_URL}/v1`. The test still installs a lightweight fetch capture for request-shape assertions, but responses should come from aimock fixtures or aimock record mode.

apps/vscode-e2e/fixtures/.gitignore

@@ -2,3 +2,4 @@
 # Contributors should extract stable fixtures manually from these files, then delete them.
 openai-*.json
 anthropic-*.json
+xai.json

apps/vscode-e2e/src/fixtures/use-mcp-tool.ts

@@ -1,9 +1,9 @@
-import * as path from "path"
-
 import { LLMock } from "@copilotkit/aimock"
 
 const TEST_DIR_NAME = "use-mcp-tool-fixture"
 const FILESYSTEM_SERVER_NAME = "filesystem"
+const READ_FILE_RELATIVE_PATH = `${TEST_DIR_NAME}/mcp-read-target.txt`
+const WRITE_FILE_RELATIVE_PATH = `${TEST_DIR_NAME}/mcp-write-target.txt`
 
 type UseMcpToolFixture = {
 	userMessagePattern: string
@@ -15,48 +15,45 @@ type UseMcpToolFixture = {
 	id: string
 }
 
-export function addUseMcpToolResultFixtures(mock: InstanceType<typeof LLMock>, workspaceDir: string) {
-	const readFilePath = path.join(workspaceDir, TEST_DIR_NAME, "mcp-read-target.txt")
-	const writeFilePath = path.join(workspaceDir, TEST_DIR_NAME, "mcp-write-target.txt")
-
+export function addUseMcpToolResultFixtures(mock: InstanceType<typeof LLMock>) {
 	const fixtures: UseMcpToolFixture[] = [
 		{
 			userMessagePattern: "USE_MCP_TOOL_READ_FILE_SMOKE",
 			toolCallId: "call_use_mcp_tool_read_file_001",
 			toolName: "read_file",
-			toolArguments: { path: readFilePath },
+			toolArguments: { path: READ_FILE_RELATIVE_PATH },
 			result: "Read the requested file through the MCP filesystem server.",
 			id: "call_use_mcp_tool_read_file_002",
 		},
 		{
 			userMessagePattern: "USE_MCP_TOOL_WRITE_FILE_SMOKE",
 			toolCallId: "call_use_mcp_tool_write_file_001",
 			toolName: "write_file",
-			toolArguments: { path: writeFilePath, content: "Hello from MCP!" },
+			toolArguments: { path: WRITE_FILE_RELATIVE_PATH, content: "Hello from MCP!" },
 			result: "Created the requested file through the MCP filesystem server.",
 			id: "call_use_mcp_tool_write_file_002",
 		},
 		{
 			userMessagePattern: "USE_MCP_TOOL_LIST_DIRECTORY_SMOKE",
 			toolCallId: "call_use_mcp_tool_list_directory_001",
 			toolName: "list_directory",
-			toolArguments: { path: path.join(workspaceDir, TEST_DIR_NAME) },
+			toolArguments: { path: TEST_DIR_NAME },
 			result: "Listed the requested directory through the MCP filesystem server.",
 			id: "call_use_mcp_tool_list_directory_002",
 		},
 		{
 			userMessagePattern: "USE_MCP_TOOL_DIRECTORY_TREE_SMOKE",
 			toolCallId: "call_use_mcp_tool_directory_tree_001",
 			toolName: "directory_tree",
-			toolArguments: { path: path.join(workspaceDir, TEST_DIR_NAME) },
+			toolArguments: { path: TEST_DIR_NAME },
 			result: "Returned the directory tree through the MCP filesystem server.",
 			id: "call_use_mcp_tool_directory_tree_002",
 		},
 		{
 			userMessagePattern: "USE_MCP_TOOL_GET_FILE_INFO_SMOKE",
 			toolCallId: "call_use_mcp_tool_get_file_info_001",
 			toolName: "get_file_info",
-			toolArguments: { path: readFilePath },
+			toolArguments: { path: READ_FILE_RELATIVE_PATH },
 			result: "Returned the requested file metadata through the MCP filesystem server.",
 			id: "call_use_mcp_tool_get_file_info_002",
 		},
@@ -65,26 +62,35 @@ export function addUseMcpToolResultFixtures(mock: InstanceType<typeof LLMock>, w
 			toolCallId: "call_use_mcp_tool_unknown_server_001",
 			serverName: "nonexistent-server",
 			toolName: "read_file",
-			toolArguments: { path: readFilePath },
-			result: "Handled the missing MCP server gracefully.",
+			toolArguments: { path: READ_FILE_RELATIVE_PATH },
+			result: "MCP server 'nonexistent-server' is not configured. Available servers: filesystem",
 			id: "call_use_mcp_tool_unknown_server_002",
 		},
 	]
 
 	for (const fixture of fixtures) {
+		const serverName = fixture.serverName ?? FILESYSTEM_SERVER_NAME
+		const isConfiguredFilesystemTool = serverName === FILESYSTEM_SERVER_NAME
+
 		mock.addFixture({
 			match: {
 				userMessage: new RegExp(fixture.userMessagePattern),
 			},
 			response: {
 				toolCalls: [
 					{
-						name: "use_mcp_tool",
-						arguments: JSON.stringify({
-							server_name: fixture.serverName ?? FILESYSTEM_SERVER_NAME,
-							tool_name: fixture.toolName,
-							arguments: fixture.toolArguments,
-						}),
+						name: isConfiguredFilesystemTool
+							? `mcp--${FILESYSTEM_SERVER_NAME}--${fixture.toolName}`
+							: "use_mcp_tool",
+						arguments: JSON.stringify(
+							isConfiguredFilesystemTool
+								? fixture.toolArguments
+								: {
+										server_name: serverName,
+										tool_name: fixture.toolName,
+										arguments: fixture.toolArguments,
+									},
+						),
 						id: fixture.toolCallId,
 					},
 				],

apps/vscode-e2e/src/runTest.ts

@@ -94,7 +94,7 @@ async function main() {
 				addReadFileResultFixtures(mock)
 				addSearchFilesResultFixtures(mock)
 				addSubtaskFixtures(mock)
-				addUseMcpToolResultFixtures(mock, testWorkspace)
+				addUseMcpToolResultFixtures(mock)
 				addWriteToFileResultFixtures(mock)
 
 				// The modes test (switch_mode → ask) triggers a second API call whose last