fix(providers): remap Copilot CLI tool fields and surface user messages

saltbo · Copilot · saltbo · commit 24119dfc6cac · 2026-04-14T23:26:11.000-04:00
Write/Edit/Read use different field names than Claude's canonical shapes:
- write/create: path→file_path, file_text→content
- edit: path→file_path, old_str→old_string, new_str→new_string
- multi_edit: same as edit + edits array items
- read/view: path→file_path

Also handle user.message SDK events → message.user AgentEvent so the
initial prompt and follow-up messages appear in the chat history.

TODO: move tool arg types to packages/shared for type-safe mapping.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/packages/cli/src/providers/copilot.ts b/packages/cli/src/providers/copilot.ts
@@ -45,21 +45,45 @@ interface MapState {
  * (matching Claude/Codex tool_use names). Copilot CLI uses lowercase snake_case;
  * known tools are mapped to PascalCase; unknown tools pass through for the fallback UI.
  * Returns `{ name: null }` for internal CLI tools that should not be surfaced.
+ *
+ * TODO: tool arg field shapes (file_path, content, etc.) are defined only in the
+ * frontend's tool-uis.tsx. Move them to packages/shared so this mapping can be typed.
  */
 function normalizeCopilotTool(name: string, input: Record<string, unknown>): { name: string | null; input: Record<string, unknown> } {
   switch (name) {
     case "bash":
       return { name: "Bash", input };
     case "read":
     case "view":
-      return { name: "Read", input };
+      // Copilot: { path } → Claude: { file_path }
+      return { name: "Read", input: { ...input, file_path: input.path ?? input.file_path } };
     case "write":
     case "create":
-      return { name: "Write", input };
+      // Copilot: { path, file_text } → Claude: { file_path, content }
+      return { name: "Write", input: { ...input, file_path: input.path ?? input.file_path, content: input.file_text ?? input.content } };
     case "edit":
-      return { name: "Edit", input };
+      // Copilot: { path, old_str, new_str } → Claude: { file_path, old_string, new_string }
+      return {
+        name: "Edit",
+        input: {
+          ...input,
+          file_path: input.path ?? input.file_path,
+          old_string: input.old_str ?? input.old_string,
+          new_string: input.new_str ?? input.new_string,
+        },
+      };
     case "multi_edit":
-      return { name: "MultiEdit", input };
+      // Copilot: { path, edits: [{old_str, new_str}] } → Claude: { file_path, edits: [{old_string, new_string}] }
+      return {
+        name: "MultiEdit",
+        input: {
+          ...input,
+          file_path: input.path ?? input.file_path,
+          edits: Array.isArray(input.edits)
+            ? input.edits.map((e: any) => ({ ...e, old_string: e.old_str ?? e.old_string, new_string: e.new_str ?? e.new_string }))
+            : input.edits,
+        },
+      };
     case "glob":
       return { name: "Glob", input };
     case "grep":
@@ -97,6 +121,14 @@ function normalizeCopilotTool(name: string, input: Record<string, unknown>): { n
  */
 export function* mapCopilotEvent(event: SessionEvent, state: MapState): Generator<AgentEvent> {
   switch (event.type) {
+    case "user.message": {
+      // The user's prompt sent to the session — surface as message.user
+      if (event.data.content) {
+        yield { type: "message.user", text: event.data.content };
+      }
+      return;
+    }
+
     case "assistant.turn_start": {
       if (!state.turnOpen) {
         state.turnOpen = true;
diff --git a/tests/providers/copilot.test.ts b/tests/providers/copilot.test.ts
@@ -621,3 +621,85 @@ describe("unknown event type", () => {
     expect(events).toHaveLength(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// user.message
+// ---------------------------------------------------------------------------
+
+describe("user.message", () => {
+  it("emits message.user event with content when data.content is present", () => {
+    const state = makeState();
+    const event = { type: "user.message", data: { content: "Hello from user" } } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state)) as { type: string; text?: string }[];
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({ type: "message.user", text: "Hello from user" });
+  });
+
+  it("emits no events when data.content is empty string", () => {
+    const state = makeState();
+    const event = { type: "user.message", data: { content: "" } } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state));
+    expect(events).toHaveLength(0);
+  });
+
+  it("emits no events when data.content is undefined (falsy)", () => {
+    const state = makeState();
+    const event = { type: "user.message", data: {} } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state));
+    expect(events).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// normalizeCopilotTool field remapping
+// ---------------------------------------------------------------------------
+
+describe("normalizeCopilotTool field remapping", () => {
+  it("write: remaps path → file_path and file_text → content in block input", () => {
+    const state = makeState({ turnOpen: true });
+    const event = {
+      type: "assistant.message",
+      data: {
+        toolRequests: [{ toolCallId: "tw1", name: "write", arguments: { path: "/tmp/f.ts", file_text: "hello" } }],
+      },
+    } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state)) as {
+      type: string;
+      block?: { type: string; name: string; input: Record<string, unknown> };
+    }[];
+    const toolStart = events.find((e) => e.type === "block.start" && e.block?.type === "tool_use");
+    expect(toolStart?.block?.input).toMatchObject({ file_path: "/tmp/f.ts", content: "hello" });
+  });
+
+  it("edit: remaps path → file_path, old_str → old_string, new_str → new_string in block input", () => {
+    const state = makeState({ turnOpen: true });
+    const event = {
+      type: "assistant.message",
+      data: {
+        toolRequests: [{ toolCallId: "te1", name: "edit", arguments: { path: "/tmp/f.ts", old_str: "a", new_str: "b" } }],
+      },
+    } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state)) as {
+      type: string;
+      block?: { type: string; name: string; input: Record<string, unknown> };
+    }[];
+    const toolStart = events.find((e) => e.type === "block.start" && e.block?.type === "tool_use");
+    expect(toolStart?.block?.input).toMatchObject({ file_path: "/tmp/f.ts", old_string: "a", new_string: "b" });
+  });
+
+  it("read: remaps path → file_path in block input", () => {
+    const state = makeState({ turnOpen: true });
+    const event = {
+      type: "assistant.message",
+      data: {
+        toolRequests: [{ toolCallId: "tr1", name: "read", arguments: { path: "/tmp/f.ts" } }],
+      },
+    } as SessionEvent;
+    const events = collect(mapCopilotEvent(event, state)) as {
+      type: string;
+      block?: { type: string; name: string; input: Record<string, unknown> };
+    }[];
+    const toolStart = events.find((e) => e.type === "block.start" && e.block?.type === "tool_use");
+    expect(toolStart?.block?.input).toMatchObject({ file_path: "/tmp/f.ts" });
+  });
+});
