Show skill reads as ACP read tool calls

Author: nikita-ashihmin

src/CodexAcpServer.ts

@@ -54,6 +54,7 @@ import {
     createImageGenerationUpdate,
     createImageViewUpdate,
     createMcpToolCallUpdate,
+    createSkillReadUpdate,
     formatWebSearchTitle,
 } from "./CodexToolCallMapper";
 import {
@@ -1027,7 +1028,11 @@ export class CodexAcpServer {
     private createUserMessageUpdates(item: ThreadItem & { type: "userMessage" }): UpdateSessionEvent[] {
         const updates: UpdateSessionEvent[] = [];
         const messageId = item.id;
-        for (const input of item.content) {
+        for (const [index, input] of item.content.entries()) {
+            if (input.type === "skill") {
+                updates.push(createSkillReadUpdate(`${messageId}.skill.${index}`, input));
+                continue;
+            }
             const blocks = this.userInputToContentBlocks(input);
             for (const block of blocks) {
                 updates.push(createUserMessageChunk(block, messageId));

src/CodexEventHandler.ts

@@ -46,6 +46,7 @@ import {
     createImageViewUpdate,
     createMcpRawInput,
     createMcpRawOutput,
+    createSkillReadUpdate,
     createFuzzyFileSearchComplete,
     createFuzzyFileSearchStartOrUpdate,
     createMcpToolCallUpdate,
@@ -86,13 +87,20 @@ export class CodexEventHandler {
 
     async handleNotification(notification: ServerNotification) {
         const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
-        const updateEvent = await this.createUpdateEvent(notification);
-        if (updateEvent) {
+        const updateEvents = await this.createUpdateEvent(notification);
+        for (const updateEvent of this.asUpdateEvents(updateEvents)) {
             await session.update(updateEvent);
         }
     }
 
-    private async createUpdateEvent(notification: ServerNotification): Promise<UpdateSessionEvent | null> {
+    private asUpdateEvents(update: UpdateSessionEvent | UpdateSessionEvent[] | null): UpdateSessionEvent[] {
+        if (!update) {
+            return [];
+        }
+        return Array.isArray(update) ? update : [update];
+    }
+
+    private async createUpdateEvent(notification: ServerNotification): Promise<UpdateSessionEvent | UpdateSessionEvent[] | null> {
         /*
         TODO split UpdateSessionEvent to improve completion
         createUpdateEvent({
@@ -304,7 +312,7 @@ export class CodexEventHandler {
         return createAgentTextThoughtChunk(text, messageId);
     }
 
-    private async createItemEvent(event: ItemStartedNotification): Promise<UpdateSessionEvent | null> {
+    private async createItemEvent(event: ItemStartedNotification): Promise<UpdateSessionEvent | UpdateSessionEvent[] | null> {
         switch (event.item.type) {
             case "fileChange":
                 return await createFileChangeUpdate(event.item);
@@ -331,9 +339,10 @@ export class CodexEventHandler {
                 return createImageGenerationStartUpdate(event.item);
             case "collabAgentToolCall":
                 return createCollabAgentToolCallUpdate(event.item);
+            case "userMessage":
+                return this.createUserMessageSkillReadUpdates(event.item);
             case "subAgentActivity":
             case "sleep":
-            case "userMessage":
             case "hookPrompt":
             case "agentMessage":
             case "reasoning":
@@ -345,6 +354,15 @@ export class CodexEventHandler {
         }
     }
 
+    private createUserMessageSkillReadUpdates(item: ThreadItem & { type: "userMessage" }): UpdateSessionEvent[] {
+        return item.content.flatMap((input, index) => {
+            if (input.type !== "skill") {
+                return [];
+            }
+            return [createSkillReadUpdate(`${item.id}.skill.${index}`, input)];
+        });
+    }
+
     private async completeItemEvent(event: ItemCompletedNotification): Promise<UpdateSessionEvent | null> {
         switch (event.item.type) {
             case "fileChange":

src/CodexToolCallMapper.ts

@@ -25,6 +25,7 @@ import type {
     McpToolCallStatus,
     PatchApplyStatus,
     ThreadItem,
+    UserInput,
 } from "./app-server/v2";
 import type { JsonValue } from "./app-server/serde_json/JsonValue";
 import {logger} from "./Logger";
@@ -41,6 +42,7 @@ type GuardianApprovalReviewNotification =
 type WebSearchItem = ThreadItem & { type: "webSearch" };
 type CollabAgentToolCallItem = ThreadItem & { type: "collabAgentToolCall" };
 type CommandExecutionItem = ThreadItem & { type: "commandExecution" };
+type SkillInput = Extract<UserInput, { type: "skill" }>;
 type AcpToolCallEvent = Extract<UpdateSessionEvent, { sessionUpdate: "tool_call" }>;
 
 function toAcpStatus(status: CodexItemStatus): AcpToolCallStatus {
@@ -176,6 +178,25 @@ export function createImageViewUpdate(
     };
 }
 
+export function createSkillReadUpdate(
+    id: string,
+    skill: SkillInput
+): UpdateSessionEvent {
+    return {
+        sessionUpdate: "tool_call",
+        toolCallId: id,
+        kind: "read",
+        title: `Read ${skill.name} skill`,
+        status: "completed",
+        locations: [{ path: skill.path }],
+        rawInput: {
+            type: "skill",
+            name: skill.name,
+            path: skill.path,
+        },
+    };
+}
+
 export function createImageGenerationStartUpdate(
     item: ThreadItem & { type: "imageGeneration" }
 ): UpdateSessionEvent {

src/__tests__/CodexACPAgent/skill-read-events.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ServerNotification } from "../../app-server";
+import type { SessionState } from "../../CodexAcpServer";
+import { AgentMode } from "../../AgentMode";
+import {
+    createCodexMockTestFixture,
+    createTestSessionState,
+    setupPromptAndSendNotifications,
+    type CodexMockTestFixture,
+} from "../acp-test-utils";
+
+describe("CodexEventHandler - skill read events", () => {
+    let mockFixture: CodexMockTestFixture;
+    const sessionId = "test-session-id";
+
+    beforeEach(() => {
+        mockFixture = createCodexMockTestFixture();
+        vi.clearAllMocks();
+    });
+
+    const sessionState: SessionState = createTestSessionState({
+        sessionId,
+        currentModelId: "model-id[effort]",
+        agentMode: AgentMode.DEFAULT_AGENT_MODE,
+    });
+
+    it("maps skill user inputs to read tool calls", async () => {
+        const notification: ServerNotification = {
+            method: "item/started",
+            params: {
+                threadId: sessionId,
+                turnId: "turn-1",
+                startedAtMs: 0,
+                item: {
+                    type: "userMessage",
+                    id: "user-message-1",
+                    clientId: null,
+                    content: [
+                        {
+                            type: "skill",
+                            name: "UI Accessibility",
+                            path: "/skills/ui-accessibility/SKILL.md",
+                        },
+                        {
+                            type: "skill",
+                            name: "Code Style",
+                            path: "/skills/code-style/SKILL.md",
+                        },
+                    ],
+                },
+            },
+        };
+
+        await setupPromptAndSendNotifications(mockFixture, sessionId, sessionState, [notification]);
+
+        const updates = mockFixture.getAcpConnectionEvents([]).map(event => event.args[0].update);
+        expect(updates).toEqual([
+            {
+                sessionUpdate: "tool_call",
+                toolCallId: "user-message-1.skill.0",
+                kind: "read",
+                title: "Read UI Accessibility skill",
+                status: "completed",
+                locations: [{ path: "/skills/ui-accessibility/SKILL.md" }],
+                rawInput: {
+                    type: "skill",
+                    name: "UI Accessibility",
+                    path: "/skills/ui-accessibility/SKILL.md",
+                },
+            },
+            {
+                sessionUpdate: "tool_call",
+                toolCallId: "user-message-1.skill.1",
+                kind: "read",
+                title: "Read Code Style skill",
+                status: "completed",
+                locations: [{ path: "/skills/code-style/SKILL.md" }],
+                rawInput: {
+                    type: "skill",
+                    name: "Code Style",
+                    path: "/skills/code-style/SKILL.md",
+                },
+            },
+        ]);
+    });
+});