@ccpocket/bridge 1.25.0 → 1.26.0

package/dist/codex-process.js

@@ -8,6 +8,8 @@ export class CodexProcess extends EventEmitter {
     child = null;
     _status = "starting";
     _threadId = null;
+    _agentNickname = null;
+    _agentRole = null;
     stopped = false;
     startModel;
     inputResolve = null;
@@ -43,6 +45,12 @@ export class CodexProcess extends EventEmitter {
     get sessionId() {
         return this._threadId;
     }
+    get agentNickname() {
+        return this._agentNickname;
+    }
+    get agentRole() {
+        return this._agentRole;
+    }
     get isRunning() {
         return this.child !== null;
     }
@@ -89,12 +97,61 @@ export class CodexProcess extends EventEmitter {
     async archiveThread(threadId) {
         await this.request("thread/archive", { threadId });
     }
+    async listThreads(params = {}) {
+        const result = await this.request("thread/list", {
+            sortKey: "updated_at",
+            archived: false,
+            ...(params.limit != null ? { limit: params.limit } : {}),
+            ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
+            ...(params.cwd ? { cwd: params.cwd } : {}),
+            ...(params.searchTerm ? { searchTerm: params.searchTerm } : {}),
+        });
+        const data = Array.isArray(result.data)
+            ? result.data.map((entry) => toCodexThreadSummary(entry))
+            : [];
+        return {
+            data,
+            nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+        };
+    }
     start(projectPath, options) {
         if (this.child) {
             this.stop();
         }
+        this.prepareLaunch(projectPath, options);
+        this.launchAppServer(projectPath, options);
+        void this.bootstrap(projectPath, options);
+    }
+    async initializeOnly(projectPath) {
+        if (this.child) {
+            this.stop();
+        }
+        this.prepareLaunch(projectPath);
+        this.launchAppServer(projectPath);
+        await this.initializeRpcConnection();
+        this.setStatus("idle");
+    }
+    stop() {
+        this.stopped = true;
+        if (this.inputResolve) {
+            this.inputResolve({ text: "" });
+            this.inputResolve = null;
+        }
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.rejectAllPending(new Error("stopped"));
+        if (this.child) {
+            this.child.kill("SIGTERM");
+            this.child = null;
+        }
+        this.setStatus("idle");
+        console.log("[codex-process] Stopped");
+    }
+    prepareLaunch(projectPath, options) {
         this.stopped = false;
         this._threadId = null;
+        this._agentNickname = null;
+        this._agentRole = null;
         this.pendingTurnId = null;
         this.pendingTurnCompletion = null;
         this.pendingApprovals.clear();
@@ -106,6 +163,9 @@ export class CodexProcess extends EventEmitter {
         this.lastPlanItemText = null;
         this.pendingPlanCompletion = null;
         this._pendingPlanInput = null;
+        this._projectPath = projectPath;
+    }
+    launchAppServer(projectPath, options) {
         console.log(`[codex-process] Starting app-server (cwd: ${projectPath}, sandbox: ${options?.sandboxMode ?? "workspace-write"}, approval: ${options?.approvalPolicy ?? "never"}, model: ${options?.model ?? "default"}, collaboration: ${this._collaborationMode})`);
         const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
             cwd: projectPath,
@@ -142,23 +202,6 @@ export class CodexProcess extends EventEmitter {
             this.setStatus("idle");
             this.emit("exit", code);
         });
-        void this.bootstrap(projectPath, options);
-    }
-    stop() {
-        this.stopped = true;
-        if (this.inputResolve) {
-            this.inputResolve({ text: "" });
-            this.inputResolve = null;
-        }
-        this.pendingApprovals.clear();
-        this.pendingUserInputs.clear();
-        this.rejectAllPending(new Error("stopped"));
-        if (this.child) {
-            this.child.kill("SIGTERM");
-            this.child = null;
-        }
-        this.setStatus("idle");
-        console.log("[codex-process] Stopped");
     }
     interrupt() {
         if (!this._threadId || !this.pendingTurnId)
@@ -211,9 +254,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "accept",
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
         this.emitToolResult(pending.toolUseId, "Approved");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -226,12 +267,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "accept",
-            acceptSettings: {
-                forSession: true,
-            },
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
         this.emitToolResult(pending.toolUseId, "Approved (always)");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -249,9 +285,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingApprovals.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            decision: "decline",
-        });
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "decline"));
         this.emitToolResult(pending.toolUseId, "Rejected");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
@@ -264,9 +298,7 @@ export class CodexProcess extends EventEmitter {
             return;
         }
         this.pendingUserInputs.delete(pending.toolUseId);
-        this.respondToServerRequest(pending.requestId, {
-            answers: buildUserInputAnswers(pending.questions, result),
-        });
+        this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
         this.emitToolResult(pending.toolUseId, "Answered");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
@@ -378,21 +410,13 @@ export class CodexProcess extends EventEmitter {
     }
     async bootstrap(projectPath, options) {
         try {
-            await this.request("initialize", {
-                clientInfo: {
-                    name: "ccpocket_bridge",
-                    version: "1.0.0",
-                    title: "ccpocket bridge",
-                },
-                capabilities: {
-                    experimentalApi: true,
-                },
-            });
-            this.notify("initialized", {});
+            await this.initializeRpcConnection();
             const threadParams = {
                 cwd: projectPath,
                 approvalPolicy: normalizeApprovalPolicy(options?.approvalPolicy ?? "never"),
                 sandbox: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+                experimentalRawEvents: false,
+                persistExtendedHistory: true,
             };
             if (options?.model)
                 threadParams.model = options.model;
@@ -412,6 +436,12 @@ export class CodexProcess extends EventEmitter {
             if (options?.threadId) {
                 threadParams.threadId = options.threadId;
             }
+            else {
+                threadParams.experimentalRawEvents = false;
+            }
+            if (options?.threadId) {
+                threadParams.persistExtendedHistory = true;
+            }
             const response = await this.request(method, threadParams);
             const thread = response.thread;
             const threadId = typeof thread?.id === "string"
@@ -448,6 +478,19 @@ export class CodexProcess extends EventEmitter {
             this.emit("exit", 1);
         }
     }
+    async initializeRpcConnection() {
+        await this.request("initialize", {
+            clientInfo: {
+                name: "ccpocket_bridge",
+                version: "1.0.0",
+                title: "ccpocket bridge",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        this.notify("initialized", {});
+    }
     /**
      * Fetch skills from Codex app-server via `skills/list` RPC and emit them
      * as a `supported_commands` system message so the Flutter client can display
@@ -639,6 +682,11 @@ export class CodexProcess extends EventEmitter {
                     ...(typeof params.cwd === "string" ? { cwd: params.cwd } : {}),
                     ...(params.commandActions ? { commandActions: params.commandActions } : {}),
                     ...(params.networkApprovalContext ? { networkApprovalContext: params.networkApprovalContext } : {}),
+                    ...(params.additionalPermissions ? { additionalPermissions: params.additionalPermissions } : {}),
+                    ...(params.skillMetadata ? { skillMetadata: params.skillMetadata } : {}),
+                    ...(params.proposedExecpolicyAmendment ? { proposedExecpolicyAmendment: params.proposedExecpolicyAmendment } : {}),
+                    ...(params.proposedNetworkPolicyAmendments ? { proposedNetworkPolicyAmendments: params.proposedNetworkPolicyAmendments } : {}),
+                    ...(params.availableDecisions ? { availableDecisions: params.availableDecisions } : {}),
                     ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
                 };
                 this.pendingApprovals.set(toolUseId, {
@@ -646,6 +694,7 @@ export class CodexProcess extends EventEmitter {
                     toolUseId,
                     toolName: "Bash",
                     input,
+                    kind: "command",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -660,6 +709,7 @@ export class CodexProcess extends EventEmitter {
                 const toolUseId = this.extractToolUseId(params, id);
                 const input = {
                     ...(Array.isArray(params.changes) ? { changes: params.changes } : {}),
+                    ...(typeof params.grantRoot === "string" ? { grantRoot: params.grantRoot } : {}),
                     ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
                 };
                 this.pendingApprovals.set(toolUseId, {
@@ -667,6 +717,7 @@ export class CodexProcess extends EventEmitter {
                     toolUseId,
                     toolName: "FileChange",
                     input,
+                    kind: "file",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -694,11 +745,13 @@ export class CodexProcess extends EventEmitter {
                 this.pendingUserInputs.set(toolUseId, {
                     requestId: id,
                     toolUseId,
+                    toolName: "AskUserQuestion",
                     questions: questions.map((q) => ({
                         id: q.id,
                         question: q.question,
                     })),
                     input,
+                    kind: "questions",
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -709,6 +762,50 @@ export class CodexProcess extends EventEmitter {
                 this.setStatus("waiting_approval");
                 break;
             }
+            case "item/permissions/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const requestedPermissions = asRecord(params.permissions) ?? {};
+                const input = {
+                    permissions: requestedPermissions,
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                    kind: "permissions",
+                    requestedPermissions,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "mcpServer/elicitation/request": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const elicitation = createElicitationInput(params);
+                this.pendingUserInputs.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    questions: elicitation.questions,
+                    input: elicitation.input,
+                    kind: elicitation.kind,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    input: elicitation.input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
             default:
                 this.respondToServerRequest(id, {});
                 break;
@@ -721,6 +818,8 @@ export class CodexProcess extends EventEmitter {
                 if (typeof thread?.id === "string") {
                     this._threadId = thread.id;
                 }
+                this._agentNickname = stringOrNull(thread?.agentNickname);
+                this._agentRole = stringOrNull(thread?.agentRole);
                 break;
             }
             case "turn/started": {
@@ -811,6 +910,10 @@ export class CodexProcess extends EventEmitter {
                 });
                 break;
             }
+            case "serverRequest/resolved": {
+                this.handleServerRequestResolved(params);
+                break;
+            }
             default:
                 break;
         }
@@ -928,6 +1031,56 @@ export class CodexProcess extends EventEmitter {
                 });
                 break;
             }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: tool,
+                                input: toToolUseInput(item.arguments),
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const toolName = "SubAgent";
+                const input = {
+                    tool,
+                    ...(typeof item.prompt === "string" ? { prompt: item.prompt } : {}),
+                    ...(typeof item.senderThreadId === "string" ? { senderThreadId: item.senderThreadId } : {}),
+                    ...(Array.isArray(item.receiverThreadIds) ? { receiverThreadIds: item.receiverThreadIds } : {}),
+                    ...(typeof item.model === "string" ? { model: item.model } : {}),
+                    ...(typeof item.reasoningEffort === "string" ? { reasoningEffort: item.reasoningEffort } : {}),
+                    ...(item.agentsStates ? { agentsStates: item.agentsStates } : {}),
+                };
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: toolName,
+                                input,
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
             default:
                 break;
         }
@@ -990,6 +1143,7 @@ export class CodexProcess extends EventEmitter {
                 const tool = typeof item.tool === "string" ? item.tool : "unknown";
                 const toolName = `mcp:${server}/${tool}`;
                 const result = item.result ?? item.error ?? "MCP call completed";
+                const normalized = normalizeMcpToolResult(result);
                 this.emitMessage({
                     type: "assistant",
                     message: {
@@ -1009,8 +1163,22 @@ export class CodexProcess extends EventEmitter {
                 this.emitMessage({
                     type: "tool_result",
                     toolUseId: itemId,
-                    content: typeof result === "string" ? result : JSON.stringify(result),
+                    content: normalized.content,
                     toolName,
+                    ...(normalized.rawContentBlocks.length > 0
+                        ? { rawContentBlocks: normalized.rawContentBlocks }
+                        : {}),
+                });
+                break;
+            }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                const content = formatDynamicToolResult(item);
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: tool,
                 });
                 break;
             }
@@ -1040,6 +1208,27 @@ export class CodexProcess extends EventEmitter {
                 });
                 break;
             }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const status = typeof item.status === "string" ? item.status : "completed";
+                const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+                    ? item.receiverThreadIds.map((entry) => String(entry))
+                    : [];
+                const content = [
+                    `tool: ${tool}`,
+                    `status: ${status}`,
+                    ...(receiverThreadIds.length > 0
+                        ? [`agents: ${receiverThreadIds.join(", ")}`]
+                        : []),
+                ].join("\n");
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: "SubAgent",
+                });
+                break;
+            }
             case "plan": {
                 // Plan item completed — save text for plan approval emission in handleTurnCompleted()
                 const planText = typeof item.text === "string" ? item.text : "";
@@ -1150,12 +1339,51 @@ export class CodexProcess extends EventEmitter {
     extractToolUseId(params, requestId) {
         if (typeof params.approvalId === "string")
             return params.approvalId;
+        if (typeof params.elicitationId === "string")
+            return params.elicitationId;
         if (typeof params.itemId === "string")
             return params.itemId;
         if (typeof requestId === "string")
             return requestId;
         return `approval-${requestId}`;
     }
+    handleServerRequestResolved(params) {
+        const requestId = params.requestId;
+        if (requestId === undefined || requestId === null)
+            return;
+        const approval = [...this.pendingApprovals.values()].find((entry) => entry.requestId === requestId);
+        if (approval) {
+            this.pendingApprovals.delete(approval.toolUseId);
+            this.emitMessage({ type: "permission_resolved", toolUseId: approval.toolUseId });
+        }
+        const inputRequest = [...this.pendingUserInputs.values()].find((entry) => entry.requestId === requestId);
+        if (inputRequest) {
+            this.pendingUserInputs.delete(inputRequest.toolUseId);
+            this.emitMessage({ type: "permission_resolved", toolUseId: inputRequest.toolUseId });
+        }
+        if (!this.pendingPlanCompletion && this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+            this.setStatus(this.pendingTurnId ? "running" : "idle");
+        }
+    }
+}
+function buildApprovalResponse(pending, decision) {
+    if (pending.kind === "permissions") {
+        return {
+            scope: decision === "acceptForSession" ? "session" : "turn",
+            permissions: decision === "decline" ? {} : (pending.requestedPermissions ?? {}),
+        };
+    }
+    return {
+        decision,
+    };
+}
+function buildUserInputResponse(pending, rawResult) {
+    if (pending.kind === "questions") {
+        return {
+            answers: buildUserInputAnswers(pending.questions, rawResult),
+        };
+    }
+    return buildElicitationResponse(pending, rawResult);
 }
 function normalizeApprovalPolicy(value) {
     switch (value) {
@@ -1197,6 +1425,9 @@ function normalizeItemType(raw) {
 function numberOrUndefined(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+function stringOrNull(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
 function summarizeFileChanges(changes) {
     if (!Array.isArray(changes) || changes.length === 0) {
         return "No file changes";
@@ -1212,6 +1443,127 @@ function summarizeFileChanges(changes) {
     })
         .join("\n");
 }
+function toToolUseInput(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return { items: value };
+    }
+    if (value === undefined || value === null) {
+        return {};
+    }
+    return { value };
+}
+function formatDynamicToolResult(item) {
+    const status = typeof item.status === "string" ? item.status : "completed";
+    const success = typeof item.success === "boolean" ? item.success : null;
+    const contentItems = Array.isArray(item.contentItems) ? item.contentItems : null;
+    const parts = [
+        `status: ${status}`,
+        ...(success != null ? [`success: ${success}`] : []),
+    ];
+    if (contentItems && contentItems.length > 0) {
+        for (const entry of contentItems) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const record = entry;
+            const type = typeof record.type === "string" ? record.type : "item";
+            if (type === "inputText" && typeof record.text === "string") {
+                parts.push(record.text);
+                continue;
+            }
+            if (type === "inputImage" && typeof record.imageUrl === "string") {
+                parts.push(`image: ${record.imageUrl}`);
+                continue;
+            }
+            parts.push(JSON.stringify(record));
+        }
+    }
+    return parts.join("\n");
+}
+function normalizeMcpToolResult(result) {
+    if (typeof result === "string") {
+        return { content: result, rawContentBlocks: [] };
+    }
+    const record = result && typeof result === "object" && !Array.isArray(result)
+        ? result
+        : null;
+    const contentItems = Array.isArray(record?.content) ? record.content : null;
+    if (!contentItems) {
+        return {
+            content: result == null ? "MCP call completed" : JSON.stringify(result),
+            rawContentBlocks: [],
+        };
+    }
+    const textParts = [];
+    const rawContentBlocks = [];
+    for (const entry of contentItems) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const item = entry;
+        const type = typeof item.type === "string" ? item.type : "";
+        if (type === "text" && typeof item.text === "string") {
+            textParts.push(item.text);
+            rawContentBlocks.push({ type: "text", text: item.text });
+            continue;
+        }
+        if (type === "image" && typeof item.data === "string") {
+            const mimeType = typeof item.mimeType === "string"
+                ? item.mimeType
+                : typeof item.mediaType === "string"
+                    ? item.mediaType
+                    : typeof item.media_type === "string"
+                        ? item.media_type
+                        : "image/png";
+            rawContentBlocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    data: item.data,
+                    media_type: mimeType,
+                },
+            });
+            continue;
+        }
+        rawContentBlocks.push(item);
+        textParts.push(JSON.stringify(item));
+    }
+    const content = textParts.join("\n").trim();
+    if (content.length > 0) {
+        return { content, rawContentBlocks };
+    }
+    const imageCount = rawContentBlocks.filter((entry) => entry.type === "image").length;
+    if (imageCount > 0) {
+        return {
+            content: imageCount === 1 ? "Generated 1 image" : `Generated ${imageCount} images`,
+            rawContentBlocks,
+        };
+    }
+    return {
+        content: result == null ? "MCP call completed" : JSON.stringify(result),
+        rawContentBlocks,
+    };
+}
+function toCodexThreadSummary(entry) {
+    const record = entry && typeof entry === "object"
+        ? entry
+        : {};
+    const gitInfo = record.gitInfo && typeof record.gitInfo === "object"
+        ? record.gitInfo
+        : {};
+    return {
+        id: typeof record.id === "string" ? record.id : "",
+        preview: typeof record.preview === "string" ? record.preview : "",
+        createdAt: numberOrUndefined(record.createdAt) ?? 0,
+        updatedAt: numberOrUndefined(record.updatedAt) ?? 0,
+        cwd: typeof record.cwd === "string" ? record.cwd : "",
+        agentNickname: stringOrNull(record.agentNickname),
+        agentRole: stringOrNull(record.agentRole),
+        gitBranch: stringOrNull(gitInfo.branch),
+        name: stringOrNull(record.name),
+    };
+}
 /**
  * Format file changes including unified diff content for display in chat.
  * Falls back to `kind: path` summary when no diff is available.
@@ -1367,6 +1719,170 @@ function normalizeAnswerValues(value) {
     const normalized = String(value).trim();
     return normalized ? [normalized] : [];
 }
+function buildElicitationResponse(pending, rawResult) {
+    if (pending.kind === "elicitation_url") {
+        const action = parseElicitationAction(rawResult);
+        return {
+            action,
+            content: null,
+            _meta: null,
+        };
+    }
+    const parsed = parseResultObject(rawResult);
+    const content = {};
+    for (const question of pending.questions) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const answers = normalizeAnswerValues(candidate);
+        if (answers.length === 1) {
+            content[question.id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[question.id] = answers;
+        }
+    }
+    if (Object.keys(content).length === 0 && pending.questions.length === 1) {
+        const answers = normalizeAnswerValues(rawResult);
+        if (answers.length === 1) {
+            content[pending.questions[0].id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[pending.questions[0].id] = answers;
+        }
+    }
+    return {
+        action: "accept",
+        content: Object.keys(content).length > 0 ? content : null,
+        _meta: null,
+    };
+}
+function parseElicitationAction(rawResult) {
+    const normalized = rawResult.trim().toLowerCase();
+    if (normalized.includes("cancel"))
+        return "cancel";
+    if (normalized.includes("decline") || normalized.includes("deny"))
+        return "decline";
+    try {
+        const parsed = JSON.parse(rawResult);
+        const answers = parsed.answers;
+        if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+            const first = Object.values(answers)[0];
+            const answer = normalizeAnswerValues(first).join(" ").toLowerCase();
+            if (answer.includes("cancel"))
+                return "cancel";
+            if (answer.includes("decline") || answer.includes("deny"))
+                return "decline";
+        }
+    }
+    catch {
+        // Fall through to accept.
+    }
+    return "accept";
+}
+function createElicitationInput(params) {
+    const serverName = typeof params.serverName === "string" ? params.serverName : "MCP";
+    const message = typeof params.message === "string" ? params.message : "Provide input";
+    if (params.mode === "url") {
+        const url = typeof params.url === "string" ? params.url : "";
+        const question = url ? `${message}\n${url}` : message;
+        return {
+            kind: "elicitation_url",
+            questions: [{ id: "elicitation_action", question }],
+            input: {
+                mode: "url",
+                serverName,
+                url,
+                message,
+                questions: [
+                    {
+                        id: "elicitation_action",
+                        header: serverName,
+                        question,
+                        options: [
+                            { label: "Accept", description: "Continue with this request" },
+                            { label: "Decline", description: "Reject this request" },
+                            { label: "Cancel", description: "Cancel without accepting" },
+                        ],
+                        multiSelect: false,
+                        isOther: false,
+                        isSecret: false,
+                    },
+                ],
+            },
+        };
+    }
+    const schema = asRecord(params.requestedSchema);
+    const properties = asRecord(schema?.properties) ?? {};
+    const requiredFields = new Set(Array.isArray(schema?.required)
+        ? schema.required.map((entry) => String(entry))
+        : []);
+    const questions = Object.entries(properties)
+        .filter(([, value]) => value && typeof value === "object")
+        .map(([key, value]) => {
+        const field = value;
+        const title = typeof field.title === "string" ? field.title : key;
+        const description = typeof field.description === "string" ? field.description : message;
+        const enumValues = Array.isArray(field.enum) ? field.enum.map((entry) => String(entry)) : [];
+        const type = typeof field.type === "string" ? field.type : "";
+        const options = enumValues.length > 0
+            ? enumValues.map((entry, index) => ({
+                label: entry,
+                description: index === 0 ? description : "",
+            }))
+            : type === "boolean"
+                ? [
+                    { label: "true", description: description },
+                    { label: "false", description: "" },
+                ]
+                : [];
+        return {
+            id: key,
+            question: requiredFields.has(key) ? `${title} (required)` : title,
+            header: serverName,
+            options,
+            isOther: options.length === 0,
+            isSecret: false,
+        };
+    });
+    const normalizedQuestions = questions.length > 0
+        ? questions
+        : [
+            {
+                id: "value",
+                question: message,
+                header: serverName,
+                options: [],
+                isOther: true,
+                isSecret: false,
+            },
+        ];
+    return {
+        kind: "elicitation_form",
+        questions: normalizedQuestions.map((question) => ({
+            id: question.id,
+            question: question.question,
+        })),
+        input: {
+            mode: "form",
+            serverName,
+            message,
+            requestedSchema: schema,
+            questions: normalizedQuestions.map((question) => ({
+                id: question.id,
+                header: question.header,
+                question: question.question,
+                options: question.options,
+                multiSelect: false,
+                isOther: question.isOther,
+                isSecret: question.isSecret,
+            })),
+        },
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 function formatPlanUpdateText(params) {
     const stepsRaw = params.plan;
     if (!Array.isArray(stepsRaw) || stepsRaw.length === 0)