Merge branch 'main' into codex/plan-command-action

Author: nikita-ashihmin

package-lock.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "",
   "main": "dist/index.js",
   "bin": {

package.json

@@ -621,6 +621,10 @@ export class CodexAcpClient {
                 await this.waitForSessionNotifications(sessionId);
                 return await elicitationHandler.handleElicitation(params);
             },
+            handleUserInput: async (params) => {
+                await this.waitForSessionNotifications(sessionId);
+                return await elicitationHandler.handleUserInput(params);
+            },
         });
     }
 

src/CodexAcpClient.ts

@@ -53,6 +53,7 @@ import {
 } from "./AcpExtensions";
 import {
     createCollabAgentToolCallUpdate,
+    createCompletedContextCompactionUpdate,
     createCommandExecutionCompleteUpdate,
     createCommandExecutionUpdate,
     createDynamicToolCallUpdate,
@@ -110,6 +111,8 @@ export interface SessionState {
     sessionMcpServers?: Array<string>;
     terminalOutputMode: TerminalOutputMode;
     currentGoal?: ThreadGoalSnapshot | null;
+    sessionTitle: string | null;
+    sessionTitleSource: "unset" | "fallback" | "explicit" | "unknown";
 }
 
 interface ActiveAuthState {
@@ -425,6 +428,8 @@ export class CodexAcpServer {
             currentModelSupportsFast: currentModelSupportsFast,
             sessionMcpServers: sessionMcpServers,
             terminalOutputMode: this.terminalOutputMode,
+            sessionTitle: null,
+            sessionTitleSource: "sessionId" in request ? "unknown" : "unset",
         };
         this.sessions.set(sessionId, sessionState);
         resumeSubscribed = false;
@@ -972,6 +977,8 @@ export class CodexAcpServer {
             currentModelSupportsFast: currentModelSupportsFast,
             sessionMcpServers: sessionMcpServers,
             terminalOutputMode: this.terminalOutputMode,
+            sessionTitle: null,
+            sessionTitleSource: "unset",
         };
         this.sessions.set(sessionId, sessionState);
         subscribed = false;
@@ -999,6 +1006,7 @@ export class CodexAcpServer {
     private async streamThreadHistory(sessionId: string, thread: Thread): Promise<void> {
         const session = new ACPSessionConnection(this.connection, sessionId);
         const sessionState = this.getSessionState(sessionId);
+        await this.publishThreadHistoryTitle(session, sessionState, thread);
         const responseItemFallbackUpdates = await createResponseItemHistoryFallbackUpdates(
             thread,
             sessionState.terminalOutputMode,
@@ -1020,6 +1028,67 @@ export class CodexAcpServer {
         }
     }
 
+    private async publishThreadHistoryTitle(
+        session: ACPSessionConnection,
+        sessionState: SessionState,
+        thread: Thread,
+    ): Promise<void> {
+        const explicitTitle = this.normalizeSessionTitle(thread.name);
+        if (explicitTitle) {
+            sessionState.sessionTitle = explicitTitle;
+            sessionState.sessionTitleSource = "explicit";
+            await session.update({
+                sessionUpdate: "session_info_update",
+                title: explicitTitle,
+            });
+            return;
+        }
+
+        const historyTitle = this.findFirstUserMessageTitle(thread)
+            ?? this.normalizeSessionTitle(thread.preview);
+        await this.publishFallbackSessionTitle(sessionState, historyTitle);
+    }
+
+    private findFirstUserMessageTitle(thread: Thread): string | null {
+        for (const turn of thread.turns) {
+            for (const item of turn.items) {
+                if (item.type !== "userMessage") continue;
+                const title = this.normalizeSessionTitle(item.content
+                    .filter((input): input is Extract<UserInput, {type: "text"}> => input.type === "text")
+                    .map(input => input.text)
+                    .join(" "));
+                if (title) return title;
+            }
+        }
+        return null;
+    }
+
+    private async publishFallbackSessionTitle(
+        sessionState: SessionState,
+        title: string | null,
+    ): Promise<void> {
+        if (sessionState.sessionTitleSource !== "unset" || !title) return;
+        sessionState.sessionTitle = title;
+        sessionState.sessionTitleSource = "fallback";
+        const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+        await session.update({
+            sessionUpdate: "session_info_update",
+            title,
+        });
+    }
+
+    private createPromptFallbackTitle(prompt: acp.ContentBlock[]): string | null {
+        return this.normalizeSessionTitle(prompt
+            .filter((block): block is Extract<acp.ContentBlock, {type: "text"}> => block.type === "text")
+            .map(block => block.text)
+            .join(" "));
+    }
+
+    private normalizeSessionTitle(title: string | null | undefined): string | null {
+        const normalized = title?.replace(/\s+/g, " ").trim() ?? "";
+        return normalized.length > 0 ? normalized : null;
+    }
+
     private async createHistoryUpdates(item: ThreadItem, sessionState: SessionState): Promise<UpdateSessionEvent[]> {
         switch (item.type) {
             case "userMessage":
@@ -1066,7 +1135,7 @@ export class CodexAcpServer {
             case "exitedReviewMode":
                 return [this.createReviewModeUpdate(item, false)];
             case "contextCompaction":
-                return [this.createContextCompactionUpdate()];
+                return [createCompletedContextCompactionUpdate(item)];
             case "plan":
                 return [this.createPlanUpdate(item)];
         }
@@ -1119,16 +1188,6 @@ export class CodexAcpServer {
         };
     }
 
-    private createContextCompactionUpdate(): UpdateSessionEvent {
-        return {
-            sessionUpdate: "agent_message_chunk",
-            content: {
-                type: "text",
-                text: "Context compacted.",
-            },
-        };
-    }
-
     private createPlanUpdate(
         item: ThreadItem & { type: "plan" }
     ): UpdateSessionEvent {
@@ -1636,6 +1695,11 @@ export class CodexAcpServer {
                 throw error;
             }
 
+            await this.publishFallbackSessionTitle(
+                sessionState,
+                this.createPromptFallbackTitle(params.prompt),
+            );
+
             return {
                 stopReason: "end_turn",
                 usage: this.buildPromptUsage(sessionState.lastTokenUsage),

src/CodexAcpServer.ts

@@ -51,6 +51,8 @@ import type {
     ThreadStartResponse,
     ThreadUnsubscribeParams,
     ThreadUnsubscribeResponse,
+    ToolRequestUserInputParams,
+    ToolRequestUserInputResponse,
     TurnCompletedNotification,
     TurnInterruptParams,
     TurnInterruptResponse,
@@ -73,6 +75,7 @@ export interface ApprovalHandler {
 
 export interface ElicitationHandler {
     handleElicitation(params: McpServerElicitationRequestParams): Promise<McpServerElicitationRequestResponse>;
+    handleUserInput(params: ToolRequestUserInputParams): Promise<ToolRequestUserInputResponse>;
 }
 
 export type McpStartupFailure = {
@@ -110,6 +113,12 @@ const McpServerElicitationRequest = new RequestType<
     void
 >('mcpServer/elicitation/request');
 
+const ToolRequestUserInputRequest = new RequestType<
+    ToolRequestUserInputParams,
+    ToolRequestUserInputResponse,
+    void
+>('item/tool/requestUserInput');
+
 const GOAL_RUNTIME_EFFECTS_GRACE_MS = 1_000;
 
 /**
@@ -217,6 +226,17 @@ export class CodexAppServerClient {
             }
             return await handler.handleElicitation(params);
         });
+
+        this.connection.onRequest(ToolRequestUserInputRequest, async (params) => {
+            if (this.isStaleTurn(params.threadId, params.turnId)) {
+                return { answers: {} };
+            }
+            const handler = this.elicitationHandlers.get(params.threadId);
+            if (!handler) {
+                return { answers: {} };
+            }
+            return await handler.handleUserInput(params);
+        });
     }
 
     onApprovalRequest(threadId: string, handler: ApprovalHandler): void {

src/CodexAppServerClient.ts

@@ -282,8 +282,8 @@ export class CodexCommands {
                 return { handled: true };
             }
             default:
-                await this.sendUnknownCommandMessage(commandName, sessionId);
-                return { handled: true };
+                // Let Codex resolve unrecognized commands as raw prompts.
+                return { handled: false };
         }
     }
 
@@ -385,19 +385,6 @@ export class CodexCommands {
         await session.update(createAgentTextMessageChunk(`Command "/${name}" requires ${inputHint}.`));
     }
 
-    private async sendUnknownCommandMessage(name: string, sessionId: string): Promise<void> {
-        const lines = this.getBuiltinCommands().map(command => `- /${command.name}: ${command.description}`);
-        const text = [
-            `Unknown command "/${name}".`,
-            "Available commands:"
-        ];
-        if (lines.length > 0) {
-            text.push(...lines);
-        }
-        const session = new ACPSessionConnection(this.connection, sessionId);
-        await session.update(createAgentTextMessageChunk(text.join("\n")));
-    }
-
     private buildStatusMessage(sessionState: SessionState): string {
         const agentMode = sessionState.agentMode;
         const accountText = this.formatAccountInfo(sessionState.account);