@yuandc/aica 0.1.0

package/dist/acp/providers/codex/events.js

@@ -0,0 +1,1473 @@
+import { readFileSync } from "node:fs";
+import { applyPatch, parsePatch, reversePatch } from "diff";
+const activeFuzzyFileSearchSessions = new Set();
+const activeGuardianApprovalReviews = new Set();
+export function codexAcpSessionUpdatesFromNotification(method, params, options = {}) {
+    switch (method) {
+        case "item/agentMessage/delta": {
+            const delta = stringField(params, "delta");
+            const itemId = stringField(params, "itemId");
+            const phase = itemId ? options.agentMessagePhases?.get(itemId) : "";
+            if (!delta)
+                return [];
+            if (phase === "commentary")
+                return [createTextChunkUpdate("agent_progress_chunk", delta)];
+            if (phase && phase !== "final_answer")
+                return [];
+            return [createTextChunkUpdate("agent_message_chunk", delta)];
+        }
+        case "item/reasoning/summaryTextDelta":
+        case "item/reasoning/textDelta": {
+            const delta = stringField(params, "delta");
+            return delta ? [createTextChunkUpdate("agent_thought_chunk", delta)] : [];
+        }
+        case "turn/plan/updated":
+        case "item/plan/delta":
+            return [{
+                    sessionUpdate: method === "item/plan/delta" ? "plan" : "plan_update",
+                    content: {
+                        type: "text",
+                        text: planText(params)
+                    }
+                }];
+        case "item/started":
+        case "item/completed": {
+            const item = objectField(params, "item");
+            const type = stringField(item, "type");
+            if (!item || !type || type === "userMessage" || type === "agentMessage" || type === "reasoning")
+                return [];
+            const normalizedToolUpdate = createNormalizedToolUpdate(method, item);
+            if (normalizedToolUpdate)
+                return [normalizedToolUpdate];
+            return [
+                method === "item/started"
+                    ? createGenericExecuteStartUpdate(item)
+                    : createGenericExecuteCompleteUpdate(item)
+            ];
+        }
+        case "item/commandExecution/outputDelta": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const delta = firstToolString(params, ["delta", "data", "output", "text"]);
+            if (!itemId && !delta)
+                return [];
+            return [{
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: itemId,
+                    kind: "execute",
+                    status: "in_progress",
+                    _meta: createTerminalOutputMeta(itemId, delta)
+                }];
+        }
+        case "item/commandExecution/terminalInteraction": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const stdin = stringField(params, "stdin");
+            if (!itemId)
+                return [];
+            return [{
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: itemId,
+                    kind: "execute",
+                    status: "in_progress",
+                    _meta: createTerminalOutputMeta(itemId, `\n${stdin}\n`)
+                }];
+        }
+        case "item/mcpToolCall/progress": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const message = stringField(params, "message").trim();
+            if (!itemId || !message)
+                return [];
+            return [{
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: itemId,
+                    kind: "execute",
+                    status: "in_progress",
+                    _meta: {
+                        mcp_output_delta: {
+                            data: message,
+                            terminal_id: itemId
+                        }
+                    }
+                }];
+        }
+        case "turn/diff/updated": {
+            const diff = stringField(params, "diff");
+            if (!diff)
+                return [];
+            return [{
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: stringField(params, "turnId") || "codex.diff",
+                    kind: "edit",
+                    title: "Diff updated",
+                    status: "completed",
+                    content: [{
+                            type: "diff",
+                            oldText: null,
+                            newText: diff
+                        }],
+                    rawOutput: { diff }
+                }];
+        }
+        case "thread/tokenUsage/updated":
+            return [{ sessionUpdate: "usage_update", _meta: { codex: params } }];
+        case "thread/name/updated":
+            return [{
+                    sessionUpdate: "session_info_update",
+                    title: stringField(params, "threadName") || null
+                }];
+        case "thread/status/changed":
+            return [codexSessionInfoUpdate({ threadStatus: stringField(params, "status") })];
+        case "thread/archived":
+            return [codexSessionInfoUpdate({ archived: true })];
+        case "thread/unarchived":
+            return [codexSessionInfoUpdate({ archived: false })];
+        case "thread/closed":
+            return [codexSessionInfoUpdate({ closed: true })];
+        case "account/rateLimits/updated":
+            return [createRateLimitsSessionInfoUpdate(params)];
+        case "account/updated":
+            return [codexSessionInfoUpdate({ account: normalizeObject(params) ?? params })];
+        case "configWarning": {
+            const summary = stringField(params, "summary");
+            const details = stringField(params, "details");
+            return [createTextChunkUpdate("agent_message_chunk", `Config warning: ${summary}${details ? `\n\n${details}` : ""}\n\n`)];
+        }
+        case "warning":
+            return [createTextChunkUpdate("agent_message_chunk", `Warning: ${stringField(params, "message")}\n\n`)];
+        case "model/rerouted":
+            return [createTextChunkUpdate("agent_thought_chunk", `Model rerouted from ${stringField(params, "fromModel")} to ${stringField(params, "toModel")} (${stringField(params, "reason")}).\n\n`)];
+        case "thread/compacted":
+            return [createTextChunkUpdate("agent_message_chunk", "*Context compacted to fit the model's context window.*\n\n")];
+        case "fuzzyFileSearch/sessionUpdated":
+            return [createFuzzyFileSearchStartOrUpdate(params)];
+        case "fuzzyFileSearch/sessionCompleted":
+            return [createFuzzyFileSearchComplete(params)];
+        case "item/autoApprovalReview/started":
+            return [createGuardianApprovalReviewUpdate(params, "started")];
+        case "item/autoApprovalReview/completed":
+            return [createGuardianApprovalReviewUpdate(params, "completed")];
+        case "error":
+            return [{
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: "codex.error",
+                    kind: "other",
+                    status: "failed",
+                    title: "Codex error",
+                    rawOutput: params
+                }];
+        default:
+            return [];
+    }
+}
+export function mapCodexNotification(method, params, sink, options = {}) {
+    switch (method) {
+        case "item/agentMessage/delta": {
+            const delta = stringField(params, "delta");
+            const itemId = stringField(params, "itemId");
+            const phase = itemId ? options.agentMessagePhases?.get(itemId) : "";
+            if (!delta || (phase && phase !== "commentary" && phase !== "final_answer"))
+                break;
+            const eventType = phase === "commentary" ? "agent_progress_chunk" : "agent_message_chunk";
+            const label = phase === "commentary" ? "progress" : "message";
+            sink.pushStatus("thinking", phase === "commentary" ? "处理中" : "生成回复中", textPreview(delta), method);
+            sink.pushUpdate({
+                type: eventType,
+                label,
+                text: delta,
+                raw: { method, params, update: createTextChunkUpdate(eventType, delta) },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/reasoning/summaryTextDelta":
+        case "item/reasoning/textDelta": {
+            const delta = stringField(params, "delta");
+            sink.pushStatus("thinking", "思考中", textPreview(delta), method);
+            sink.pushUpdate({
+                type: "agent_thought_chunk",
+                label: "thought",
+                ...(delta ? { text: delta } : {}),
+                raw: { method, params },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "turn/plan/updated":
+        case "item/plan/delta": {
+            sink.pushStatus("thinking", "规划中", undefined, method);
+            sink.pushUpdate({
+                type: method === "item/plan/delta" ? "plan" : "plan_update",
+                label: "plan",
+                text: planText(params),
+                raw: { method, params },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/started":
+        case "item/completed": {
+            const item = objectField(params, "item");
+            const type = stringField(item, "type");
+            const update = createNormalizedToolUpdate(method, item);
+            if (!update) {
+                const label = labelForItem(type);
+                if (type === "reasoning" || type === "agentMessage")
+                    sink.pushStatus(phaseForItem(type), label, itemDetail(item), method);
+                break;
+            }
+            const tool = normalizeToolItem(method, params, item);
+            const label = conciseToolEventLabel(type, update);
+            sink.pushStatus(phaseForItem(type), liveActivityLabelForItem(type), undefined, method);
+            sink.pushUpdate({
+                type: method === "item/started" ? "tool_call" : "tool_call_update",
+                label,
+                status: firstToolString(update, ["status"]) || (method === "item/started" ? "in_progress" : "completed"),
+                toolCallId: stringField(item, "id"),
+                raw: { method, params, tool, update },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/commandExecution/outputDelta": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const delta = firstToolString(params, ["delta", "data", "output", "text"]);
+            if (!itemId && !delta)
+                break;
+            sink.pushStatus("exploring", "执行命令", undefined, method);
+            sink.pushUpdate({
+                type: "tool_call_update",
+                label: "tool update",
+                toolCallId: itemId,
+                raw: {
+                    method,
+                    params,
+                    update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: itemId,
+                        _meta: createTerminalOutputMeta(itemId, delta)
+                    }
+                },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/commandExecution/terminalInteraction": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const stdin = stringField(params, "stdin");
+            const data = `\n${stdin}\n`;
+            if (!itemId)
+                break;
+            sink.pushStatus("exploring", "执行命令", undefined, method);
+            sink.pushUpdate({
+                type: "tool_call_update",
+                label: "tool update",
+                toolCallId: itemId,
+                raw: {
+                    method,
+                    params,
+                    update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: itemId,
+                        _meta: createTerminalOutputMeta(itemId, data)
+                    }
+                },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/mcpToolCall/progress": {
+            const itemId = stringField(params, "itemId") || stringField(params, "id") || stringField(params, "toolCallId");
+            const message = stringField(params, "message").trim();
+            if (!itemId || !message)
+                break;
+            sink.pushStatus("exploring", "调用工具", undefined, method);
+            sink.pushUpdate({
+                type: "tool_call_update",
+                label: "tool update",
+                toolCallId: itemId,
+                raw: {
+                    method,
+                    params,
+                    update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: itemId,
+                        _meta: {
+                            mcp_output_delta: {
+                                data: message,
+                                terminal_id: itemId
+                            }
+                        }
+                    }
+                },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "turn/diff/updated":
+            sink.pushStatus("exploring", "编辑文件中", "diff", method);
+            sink.pushUpdate({
+                type: "diff",
+                label: "diff",
+                text: stringField(params, "diff"),
+                raw: { method, params },
+                atMs: Date.now()
+            });
+            break;
+        case "thread/tokenUsage/updated":
+            sink.pushUpdate({
+                type: "usage_update",
+                label: "usage",
+                raw: { method, params },
+                atMs: Date.now()
+            });
+            break;
+        case "thread/name/updated":
+            pushNormalizedUpdate(sink, {
+                method,
+                params,
+                type: "session_info_update",
+                label: "session_info",
+                update: {
+                    sessionUpdate: "session_info_update",
+                    title: stringField(params, "threadName") || null
+                }
+            });
+            break;
+        case "thread/status/changed":
+            pushCodexSessionInfoUpdate(sink, method, params, { threadStatus: stringField(params, "status") });
+            break;
+        case "thread/archived":
+            pushCodexSessionInfoUpdate(sink, method, params, { archived: true });
+            break;
+        case "thread/unarchived":
+            pushCodexSessionInfoUpdate(sink, method, params, { archived: false });
+            break;
+        case "thread/closed":
+            pushCodexSessionInfoUpdate(sink, method, params, { closed: true });
+            break;
+        case "account/rateLimits/updated":
+            pushNormalizedUpdate(sink, {
+                method,
+                params,
+                type: "session_info_update",
+                label: "rate_limit",
+                update: createRateLimitsSessionInfoUpdate(params)
+            });
+            break;
+        case "configWarning": {
+            const summary = stringField(params, "summary");
+            const details = stringField(params, "details");
+            const text = `Config warning: ${summary}${details ? `\n\n${details}` : ""}\n\n`;
+            sink.pushUpdate({
+                type: "agent_message_chunk",
+                label: "message",
+                text,
+                raw: { method, params, update: createTextChunkUpdate("agent_message_chunk", text) },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "warning": {
+            const text = `Warning: ${stringField(params, "message")}\n\n`;
+            sink.pushUpdate({
+                type: "agent_message_chunk",
+                label: "message",
+                text,
+                raw: { method, params, update: createTextChunkUpdate("agent_message_chunk", text) },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "model/rerouted": {
+            const text = `Model rerouted from ${stringField(params, "fromModel")} to ${stringField(params, "toModel")} (${stringField(params, "reason")}).\n\n`;
+            sink.pushStatus("thinking", "模型已切换", textPreview(text), method);
+            sink.pushUpdate({
+                type: "agent_thought_chunk",
+                label: "thought",
+                text,
+                raw: { method, params, update: createTextChunkUpdate("agent_thought_chunk", text) },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "thread/compacted": {
+            const text = "*Context compacted to fit the model's context window.*\n\n";
+            sink.pushStatus("thinking", "上下文已压缩", undefined, method);
+            sink.pushUpdate({
+                type: "agent_message_chunk",
+                label: "message",
+                text,
+                raw: { method, params, update: createTextChunkUpdate("agent_message_chunk", text) },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "fuzzyFileSearch/sessionUpdated": {
+            const update = createFuzzyFileSearchStartOrUpdate(params);
+            sink.pushStatus("exploring", stringField(update, "title") || "Search", fuzzySearchDetail(params), method);
+            sink.pushUpdate({
+                type: update.sessionUpdate === "tool_call" ? "tool_call" : "tool_call_update",
+                label: stringField(update, "title") || "Search",
+                status: stringField(update, "status"),
+                toolCallId: stringField(update, "toolCallId"),
+                raw: { method, params, update },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "fuzzyFileSearch/sessionCompleted": {
+            const update = createFuzzyFileSearchComplete(params);
+            sink.pushUpdate({
+                type: "tool_call_update",
+                label: "Search",
+                status: stringField(update, "status"),
+                toolCallId: stringField(update, "toolCallId"),
+                raw: { method, params, update },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/autoApprovalReview/started": {
+            const update = createGuardianApprovalReviewUpdate(params, "started");
+            sink.pushStatus("exploring", "Guardian Review", guardianReviewDetail(params), method);
+            sink.pushUpdate({
+                type: update.sessionUpdate === "tool_call" ? "tool_call" : "tool_call_update",
+                label: "Guardian Review",
+                status: stringField(update, "status"),
+                toolCallId: stringField(update, "toolCallId"),
+                raw: { method, params, update },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "item/autoApprovalReview/completed": {
+            const update = createGuardianApprovalReviewUpdate(params, "completed");
+            sink.pushUpdate({
+                type: update.sessionUpdate === "tool_call" ? "tool_call" : "tool_call_update",
+                label: "Guardian Review",
+                status: stringField(update, "status"),
+                toolCallId: stringField(update, "toolCallId"),
+                raw: { method, params, update },
+                atMs: Date.now()
+            });
+            break;
+        }
+        case "account/updated":
+            pushCodexSessionInfoUpdate(sink, method, params, { account: normalizeObject(params) ?? params });
+            break;
+        case "turn/started":
+            sink.pushStatus("thinking", "思考中", undefined, method);
+            break;
+        case "turn/completed":
+            sink.pushStatus("completed", "已完成", undefined, method);
+            break;
+        case "error":
+            sink.pushStatus("failed", "执行失败", textPreview(JSON.stringify(params)), method);
+            sink.pushUpdate({
+                type: "error",
+                label: "error",
+                text: textPreview(JSON.stringify(params)),
+                raw: { method, params },
+                atMs: Date.now()
+            });
+            break;
+        default:
+            break;
+    }
+}
+export function extractAssistantTextFromTurn(turn) {
+    const items = Array.isArray(turn?.items) ? turn.items : [];
+    return items
+        .map((item) => {
+        if (stringField(item, "type") !== "agentMessage")
+            return "";
+        return stringField(item, "text");
+    })
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+function labelForItem(type) {
+    switch (type) {
+        case "commandExecution":
+            return "执行命令中";
+        case "fileChange":
+            return "编辑文件中";
+        case "mcpToolCall":
+        case "dynamicToolCall":
+            return "调用工具中";
+        case "webSearch":
+            return "搜索中";
+        case "imageGeneration":
+            return "生成图片中";
+        case "reasoning":
+            return "思考中";
+        case "agentMessage":
+            return "生成回复中";
+        default:
+            return "处理中";
+    }
+}
+function liveActivityLabelForItem(type) {
+    switch (type) {
+        case "commandExecution":
+            return "执行命令";
+        case "fileChange":
+            return "编辑文件";
+        case "mcpToolCall":
+        case "dynamicToolCall":
+            return "调用工具";
+        case "webSearch":
+        case "fuzzyFileSearch":
+            return "搜索";
+        case "imageView":
+            return "查看图片";
+        case "imageGeneration":
+            return "生成图片";
+        default:
+            return labelForItem(type);
+    }
+}
+function conciseToolEventLabel(type, update) {
+    const kind = firstToolString(update, ["kind"]);
+    if (kind === "read")
+        return firstToolString(update, ["title"]) || "读取文件";
+    if (kind === "search")
+        return firstToolString(update, ["title"]) || "搜索";
+    if (kind === "edit")
+        return "编辑文件";
+    if (kind === "execute")
+        return "执行命令";
+    if (kind === "think")
+        return "思考中";
+    if (kind === "other")
+        return firstToolString(update, ["title"]) || liveActivityLabelForItem(type);
+    return liveActivityLabelForItem(type);
+}
+function phaseForItem(type) {
+    if (type === "imageGeneration")
+        return "image_generation";
+    if (type === "reasoning" || type === "agentMessage" || type === "plan")
+        return "thinking";
+    return "exploring";
+}
+function itemDetail(item) {
+    if (!item)
+        return undefined;
+    for (const key of ["command", "path", "tool", "server", "query", "text"]) {
+        const value = stringField(item, key);
+        if (value)
+            return textPreview(value);
+    }
+    return undefined;
+}
+function normalizeToolItem(method, params, item) {
+    const type = stringField(item, "type");
+    const id = stringField(item, "id") || stringField(params, "itemId");
+    const rawInput = firstToolString(item, ["rawInput", "raw_input", "command", "query", "path", "text", "input"]);
+    const command = type === "commandExecution" ? firstToolString(item, ["command", "rawInput", "raw_input"]) : "";
+    const fileChange = firstFileChange(item);
+    const filePath = firstToolString(item, ["path", "filePath", "file_path", "relativePath", "absolutePath"]) || fileChange.path;
+    const aggregatedOutput = firstToolString(item, ["aggregatedOutput", "aggregated_output", "formattedOutput", "formatted_output", "output", "stdout", "stderr"]);
+    const commandActions = arrayField(item, "commandActions") || arrayField(item, "command_actions") || arrayField(item, "actions") || fileChangeActions(item);
+    const formattedOutput = formatToolOutput(type, aggregatedOutput, item);
+    const displayName = toolDisplayName(type, { command, path: filePath, rawInput, item });
+    const summary = textPreview(firstNonEmpty(command, filePath, rawInput, aggregatedOutput));
+    return removeEmpty({
+        id,
+        type,
+        method,
+        displayName,
+        rawInput,
+        raw_input: rawInput,
+        command,
+        path: filePath,
+        action: firstToolString(item, ["action", "changeType", "operation"]) || fileChange.action,
+        commandActions,
+        command_actions: commandActions.length > 0 ? commandActions : undefined,
+        aggregatedOutput,
+        aggregated_output: aggregatedOutput,
+        formatted_output: formattedOutput,
+        summary
+    });
+}
+function createNormalizedToolUpdate(method, item) {
+    if (!item)
+        return null;
+    const type = stringField(item, "type");
+    switch (type) {
+        case "commandExecution":
+            return method === "item/started" ? createCommandExecutionStartUpdate(item) : createCommandExecutionCompleteUpdate(item);
+        case "fileChange":
+            return method === "item/started" ? createFileChangeStartUpdate(item) : createFileChangeCompleteUpdate(item);
+        case "mcpToolCall":
+            return method === "item/started" ? createMcpToolCallStartUpdate(item) : createMcpToolCallCompleteUpdate(item);
+        case "dynamicToolCall":
+            return method === "item/started" ? createDynamicToolCallStartUpdate(item) : createDynamicToolCallCompleteUpdate(item);
+        case "webSearch":
+            return method === "item/started" ? createWebSearchStartUpdate(item) : createWebSearchCompleteUpdate(item);
+        case "imageView":
+            return createImageViewUpdate(item);
+        case "imageGeneration":
+            return method === "item/started" ? createImageGenerationStartUpdate(item) : createImageGenerationCompleteUpdate(item);
+        default:
+            return null;
+    }
+}
+function pushNormalizedUpdate(sink, input) {
+    sink.pushUpdate({
+        type: input.type,
+        label: input.label,
+        raw: { method: input.method, params: input.params, update: input.update },
+        atMs: Date.now()
+    });
+}
+function pushCodexSessionInfoUpdate(sink, method, params, codexMetadata) {
+    pushNormalizedUpdate(sink, {
+        method,
+        params,
+        type: "session_info_update",
+        label: "session_info",
+        update: {
+            sessionUpdate: "session_info_update",
+            _meta: {
+                codex: codexMetadata
+            }
+        }
+    });
+}
+function codexSessionInfoUpdate(codexMetadata) {
+    return {
+        sessionUpdate: "session_info_update",
+        _meta: {
+            codex: codexMetadata
+        }
+    };
+}
+function createTextChunkUpdate(sessionUpdate, text) {
+    return {
+        sessionUpdate,
+        content: {
+            type: "text",
+            text
+        }
+    };
+}
+function fuzzyFileSearchToolCallId(sessionId) {
+    return `fuzzyFileSearch.${sessionId}`;
+}
+function createFuzzyFileSearchStartOrUpdate(params) {
+    const sessionId = stringField(params, "sessionId");
+    const toolCallId = fuzzyFileSearchToolCallId(sessionId);
+    const started = !activeFuzzyFileSearchSessions.has(toolCallId);
+    activeFuzzyFileSearchSessions.add(toolCallId);
+    const query = stringField(params, "query");
+    const title = searchTitle(query, "");
+    const locations = fuzzySearchLocations(params);
+    if (started) {
+        return removeEmpty({
+            sessionUpdate: "tool_call",
+            toolCallId,
+            kind: "search",
+            title,
+            status: "in_progress",
+            locations,
+            rawInput: { query }
+        });
+    }
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId,
+        title,
+        status: "in_progress",
+        locations
+    });
+}
+function createFuzzyFileSearchComplete(params) {
+    const sessionId = stringField(params, "sessionId");
+    const toolCallId = fuzzyFileSearchToolCallId(sessionId);
+    activeFuzzyFileSearchSessions.delete(toolCallId);
+    return {
+        sessionUpdate: "tool_call_update",
+        toolCallId,
+        status: "completed"
+    };
+}
+function fuzzySearchLocations(params) {
+    const files = arrayField(normalizeObject(params), "files") ?? [];
+    const locations = files
+        .map((file) => {
+        const record = normalizeObject(file);
+        if (!record)
+            return "";
+        const filePath = stringField(record, "path");
+        const root = stringField(record, "root");
+        if (!filePath)
+            return "";
+        if (filePath.startsWith("/") || !root)
+            return filePath;
+        return `${root.replace(/\/+$/, "")}/${filePath.replace(/^\/+/, "")}`;
+    })
+        .filter(Boolean)
+        .map((path) => ({ path }));
+    return locations.length > 0 ? locations : undefined;
+}
+function fuzzySearchDetail(params) {
+    const query = stringField(params, "query");
+    const files = arrayField(normalizeObject(params), "files") ?? [];
+    const count = files.length;
+    if (query && count)
+        return `${query} · ${count} files`;
+    if (query)
+        return query;
+    if (count)
+        return `${count} files`;
+    return undefined;
+}
+function guardianApprovalReviewToolCallId(reviewId) {
+    return `guardian_assessment:${reviewId}`;
+}
+function createGuardianApprovalReviewUpdate(params, phase) {
+    const reviewId = stringField(params, "reviewId");
+    const toolCallId = guardianApprovalReviewToolCallId(reviewId);
+    const started = phase === "started" && !activeGuardianApprovalReviews.has(reviewId);
+    if (phase === "started")
+        activeGuardianApprovalReviews.add(reviewId);
+    if (phase === "completed")
+        activeGuardianApprovalReviews.delete(reviewId);
+    const review = objectField(params, "review") ?? {};
+    const update = {
+        sessionUpdate: started ? "tool_call" : "tool_call_update",
+        toolCallId,
+        status: toAcpGuardianApprovalReviewStatus(stringField(review, "status")),
+        content: createGuardianApprovalReviewContent(review, objectField(params, "action")),
+        ...(started ? { kind: "think", title: "Guardian Review", rawInput: params } : { rawOutput: params })
+    };
+    return removeEmpty(update);
+}
+function toAcpGuardianApprovalReviewStatus(status) {
+    switch (status) {
+        case "inProgress":
+            return "in_progress";
+        case "approved":
+            return "completed";
+        case "denied":
+        case "aborted":
+        case "timedOut":
+            return "failed";
+        default:
+            return status || "in_progress";
+    }
+}
+function createGuardianApprovalReviewContent(review, action) {
+    const lines = [`Status: ${formatGuardianApprovalReviewStatus(stringField(review, "status"))}`];
+    const actionSummary = createGuardianApprovalReviewActionSummary(action);
+    if (actionSummary)
+        lines.push(`Action: ${actionSummary}`);
+    const riskLevel = stringField(review, "riskLevel");
+    if (riskLevel)
+        lines.push(`Risk: ${riskLevel}`);
+    const userAuthorization = stringField(review, "userAuthorization");
+    if (userAuthorization)
+        lines.push(`Authorization: ${userAuthorization}`);
+    const rationale = stringField(review, "rationale").trim();
+    if (rationale)
+        lines.push(`Rationale: ${rationale}`);
+    return [{
+            type: "content",
+            content: {
+                type: "text",
+                text: lines.join("\n")
+            }
+        }];
+}
+function formatGuardianApprovalReviewStatus(status) {
+    switch (status) {
+        case "inProgress":
+            return "In progress";
+        case "approved":
+            return "Approved";
+        case "denied":
+            return "Denied";
+        case "aborted":
+            return "Aborted";
+        case "timedOut":
+            return "Timed out";
+        default:
+            return status || "Unknown";
+    }
+}
+function createGuardianApprovalReviewActionSummary(action) {
+    if (!action)
+        return "";
+    const type = stringField(action, "type");
+    if (type === "command")
+        return [guardianCommandSourceLabel(stringField(action, "source")), stringField(action, "command")].filter(Boolean).join(" ");
+    if (type === "execve") {
+        const argv = arrayField(action, "argv")?.map((item) => stringifyToolValue(item)).filter(Boolean) ?? [];
+        const program = stringField(action, "program");
+        const command = argv.length > 0 ? argv : [program].filter(Boolean);
+        return [guardianCommandSourceLabel(stringField(action, "source")), shellJoin(command)].filter(Boolean).join(" ");
+    }
+    if (type === "applyPatch") {
+        const files = arrayField(action, "files")?.map((item) => stringifyToolValue(item)).filter(Boolean) ?? [];
+        return files.length === 1 ? `apply_patch touching ${files[0]}` : `apply_patch touching ${files.length} files`;
+    }
+    if (type === "networkAccess") {
+        const label = stringField(action, "target") || stringField(action, "host");
+        return label ? `network access to ${label}` : "network access";
+    }
+    if (type === "mcpToolCall") {
+        const label = stringField(action, "connectorName") || stringField(action, "server");
+        const toolName = stringField(action, "toolName");
+        return `MCP ${toolName} on ${label}`.trim();
+    }
+    if (type === "requestPermissions")
+        return stringField(action, "reason") || "request additional permissions";
+    return type;
+}
+function guardianCommandSourceLabel(source) {
+    if (source === "shell")
+        return "shell";
+    if (source === "unifiedExec")
+        return "exec";
+    return source;
+}
+function shellJoin(args) {
+    return args.map(shellQuote).join(" ");
+}
+function shellQuote(arg) {
+    if (arg.length === 0)
+        return "''";
+    if (/^[A-Za-z0-9_/:=+.,@%-]+$/.test(arg))
+        return arg;
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function guardianReviewDetail(params) {
+    const review = objectField(params, "review");
+    const status = review ? formatGuardianApprovalReviewStatus(stringField(review, "status")) : "";
+    const action = createGuardianApprovalReviewActionSummary(objectField(params, "action"));
+    return [status, action].filter(Boolean).join(" · ") || undefined;
+}
+function createRateLimitsSessionInfoUpdate(params) {
+    const rateLimits = objectField(params, "rateLimits") ?? {};
+    const primary = objectField(rateLimits, "primary");
+    const secondary = objectField(rateLimits, "secondary");
+    return removeEmpty({
+        sessionUpdate: "session_info_update",
+        _meta: {
+            rateLimits: removeEmpty({
+                planName: stringField(rateLimits, "planType"),
+                limitName: stringField(rateLimits, "limitName"),
+                limitId: stringField(rateLimits, "limitId"),
+                fiveHour: numberField(primary, "usedPercent") ?? null,
+                sevenDay: numberField(secondary, "usedPercent") ?? null,
+                fiveHourResetAt: stringField(primary, "resetsAt") || null,
+                sevenDayResetAt: stringField(secondary, "resetsAt") || null,
+                raw: rateLimits
+            })
+        }
+    });
+}
+function createCommandExecutionStartUpdate(item) {
+    const id = stringField(item, "id");
+    const cwd = stringField(item, "cwd");
+    const command = stringField(item, "command");
+    const actions = commandActions(item);
+    const action = actions.length === 1 ? normalizeObject(actions[0]) : null;
+    if (action) {
+        const actionType = stringField(action, "type");
+        if (actionType === "read") {
+            const path = stringField(action, "path") || stringField(action, "name");
+            return removeEmpty({
+                sessionUpdate: "tool_call",
+                toolCallId: id,
+                status: toAcpStatus(stringField(item, "status")),
+                kind: "read",
+                title: `Read file '${path}'`,
+                locations: path ? [{ path }] : undefined
+            });
+        }
+        if (actionType === "search") {
+            const query = stringField(action, "query");
+            const path = stringField(action, "path");
+            return removeEmpty({
+                sessionUpdate: "tool_call",
+                toolCallId: id,
+                status: toAcpStatus(stringField(item, "status")),
+                kind: "search",
+                title: searchTitle(query, path)
+            });
+        }
+        if (actionType === "listFiles") {
+            const path = stringField(action, "path");
+            return removeEmpty({
+                sessionUpdate: "tool_call",
+                toolCallId: id,
+                status: toAcpStatus(stringField(item, "status")),
+                kind: "read",
+                title: path ? `List files in '${path}'` : "List files"
+            });
+        }
+    }
+    return createTerminalCommandUpdate({
+        sessionUpdate: "tool_call",
+        toolCallId: id,
+        status: toAcpStatus(stringField(item, "status")),
+        kind: "execute",
+        title: stripShellPrefix(command),
+        rawInput: removeEmpty({ command, cwd })
+    }, id, cwd);
+}
+function createCommandExecutionCompleteUpdate(item) {
+    const id = stringField(item, "id");
+    const output = firstToolString(item, ["aggregatedOutput", "aggregated_output", "formattedOutput", "formatted_output", "output", "stdout", "stderr"]);
+    const exitCode = numberField(item, "exitCode");
+    const update = {
+        sessionUpdate: "tool_call_update",
+        toolCallId: id,
+        status: toAcpStatus(stringField(item, "status")),
+        rawOutput: removeEmpty({
+            formatted_output: output,
+            exit_code: exitCode
+        })
+    };
+    if (commandExecutionUsesTerminalOutput(item)) {
+        update._meta = {
+            ...(output ? createTerminalOutputMeta(id, output) : {}),
+            terminal_exit: {
+                exit_code: exitCode,
+                signal: null,
+                terminal_id: id
+            }
+        };
+    }
+    return removeEmpty(update);
+}
+function createFileChangeStartUpdate(item) {
+    const id = stringField(item, "id");
+    const content = fileChangeContent(item);
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: id,
+        title: "Editing files",
+        kind: "edit",
+        status: toAcpStatus(stringField(item, "status")),
+        content,
+        locations: fileChangeLocations(item),
+        rawInput: { changes: fileChangeActions(item) }
+    });
+}
+function createFileChangeCompleteUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        status: toAcpStatus(stringField(item, "status")),
+        content: fileChangeContent(item)
+    });
+}
+function createGenericExecuteStartUpdate(item) {
+    // `id` is an opaque Codex tool-call identifier, never a user-facing title.
+    // The specialised mappings above cover the tool types whose title can be
+    // derived reliably; an unknown item without metadata should remain generic.
+    const title = firstToolString(item, ["tool", "name", "server"]);
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: stringField(item, "id"),
+        kind: "execute",
+        title,
+        status: toAcpStatus(stringField(item, "status")),
+        rawInput: normalizeObject(item)
+    });
+}
+function createGenericExecuteCompleteUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        status: toAcpStatus(stringField(item, "status")),
+        rawOutput: normalizeObject(item)
+    });
+}
+function createMcpToolCallStartUpdate(item) {
+    const server = stringField(item, "server");
+    const tool = stringField(item, "tool");
+    return removeEmpty({
+        ...createExecuteToolCallUpdate(item, `mcp.${server}.${tool}`, createMcpRawInput(server, tool, item.arguments), createMcpRawOutput(item.result, item.error)),
+        _meta: { is_mcp_tool_call: true }
+    });
+}
+function createMcpToolCallCompleteUpdate(item) {
+    const server = stringField(item, "server");
+    const tool = stringField(item, "tool");
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        status: toAcpStatus(stringField(item, "status")),
+        rawInput: createMcpRawInput(server, tool, item.arguments),
+        rawOutput: createMcpRawOutput(item.result, item.error)
+    });
+}
+function createDynamicToolCallStartUpdate(item) {
+    return createExecuteToolCallUpdate(item, stringField(item, "tool"), { arguments: item.arguments }, undefined);
+}
+function createDynamicToolCallCompleteUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        status: toAcpStatus(stringField(item, "status"))
+    });
+}
+function createExecuteToolCallUpdate(item, title, rawInput, rawOutput) {
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: stringField(item, "id"),
+        kind: "execute",
+        title,
+        status: toAcpStatus(stringField(item, "status")),
+        rawInput,
+        rawOutput
+    });
+}
+function createMcpRawInput(server, tool, argumentsValue) {
+    return {
+        server,
+        tool,
+        arguments: argumentsValue
+    };
+}
+function createMcpRawOutput(result, error) {
+    if (result === null && error === null)
+        return undefined;
+    if (result === undefined && error === undefined)
+        return undefined;
+    return { result, error };
+}
+function createWebSearchStartUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: stringField(item, "id"),
+        kind: "search",
+        title: webSearchTitle(item),
+        status: toAcpStatus(stringField(item, "status")),
+        rawInput: normalizeObject(item)
+    });
+}
+function createWebSearchCompleteUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        title: webSearchTitle(item),
+        status: toAcpStatus(stringField(item, "status")),
+        rawInput: normalizeObject(item)
+    });
+}
+function createImageGenerationStartUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: stringField(item, "id"),
+        kind: "other",
+        title: "Image generation",
+        status: "in_progress",
+        rawInput: {
+            id: stringField(item, "id")
+        }
+    });
+}
+function createImageGenerationCompleteUpdate(item) {
+    return removeEmpty({
+        sessionUpdate: "tool_call_update",
+        toolCallId: stringField(item, "id"),
+        status: imageGenerationToolStatus(stringField(item, "status")),
+        content: imageGenerationContent(item),
+        rawOutput: imageGenerationRawOutput(item)
+    });
+}
+function createImageViewUpdate(item) {
+    const displayPath = stringField(item, "path");
+    return removeEmpty({
+        sessionUpdate: "tool_call",
+        toolCallId: stringField(item, "id"),
+        kind: "read",
+        title: `View Image ${displayPath}`,
+        status: "completed",
+        content: [{
+                type: "content",
+                content: {
+                    type: "resource_link",
+                    name: displayPath,
+                    uri: displayPath
+                }
+            }],
+        locations: [{ path: displayPath }],
+        rawInput: { path: displayPath }
+    });
+}
+function imageGenerationToolStatus(status) {
+    if (status === "completed")
+        return "completed";
+    if (status === "failed")
+        return "failed";
+    return "in_progress";
+}
+function imageGenerationContent(item) {
+    const result = normalizeObject(item.result);
+    const url = firstToolString(result, ["url", "uri", "path"]);
+    if (!url)
+        return undefined;
+    return [{
+            type: "content",
+            content: {
+                type: "resource_link",
+                name: url,
+                uri: url
+            }
+        }];
+}
+function imageGenerationRawOutput(item) {
+    const output = {
+        status: item.status,
+        revisedPrompt: item.revisedPrompt,
+        result: item.result
+    };
+    if ("savedPath" in item)
+        output.savedPath = item.savedPath ?? null;
+    return output;
+}
+function createTerminalCommandUpdate(update, terminalId, cwd) {
+    return removeEmpty({
+        ...update,
+        content: [{ type: "terminal", terminalId }],
+        _meta: {
+            terminal_info: {
+                cwd,
+                terminal_id: terminalId
+            }
+        }
+    });
+}
+function commandExecutionUsesTerminalOutput(item) {
+    const actions = commandActions(item);
+    const action = actions.length === 1 ? normalizeObject(actions[0]) : null;
+    return !action || stringField(action, "type") === "unknown";
+}
+function commandActions(item) {
+    return arrayField(item, "commandActions") || arrayField(item, "command_actions") || arrayField(item, "actions") || [];
+}
+function toAcpStatus(status) {
+    switch (status) {
+        case "inProgress":
+        case "in_progress":
+        case "started":
+        case "":
+            return "in_progress";
+        case "completed":
+            return "completed";
+        case "failed":
+        case "declined":
+        case "cancelled":
+            return "failed";
+        default:
+            return status;
+    }
+}
+function stripShellPrefix(command) {
+    const withoutShell = command.replace(/^(?:\/bin\/)?(?:bash|zsh|sh)\s+(?:-[lc]+\s+)?/, "");
+    if (withoutShell.startsWith("'") && withoutShell.endsWith("'")) {
+        return withoutShell.slice(1, -1);
+    }
+    return withoutShell;
+}
+function createTerminalOutputMeta(terminalId, data) {
+    return {
+        terminal_output_delta: {
+            data,
+            terminal_id: terminalId
+        }
+    };
+}
+function searchTitle(query, path) {
+    if (query && path)
+        return `Search for '${query}' in ${path}`;
+    if (query)
+        return `Search for '${query}'`;
+    if (path)
+        return `Search in '${path}'`;
+    return "Search";
+}
+function webSearchTitle(item) {
+    const action = normalizeObject(item.action);
+    if (!action) {
+        const query = stringField(item, "query");
+        return query ? `Web search: ${query}` : "Web search";
+    }
+    const actionType = stringField(action, "type");
+    if (actionType === "search") {
+        const queries = arrayField(action, "queries")?.map((query) => stringifyToolValue(query)).filter(Boolean) ?? [];
+        const query = stringField(action, "query") || (queries.length > 0 ? queries.join(", ") : "") || stringField(item, "query");
+        return query ? `Web search: ${query}` : "Web search";
+    }
+    if (actionType === "openPage") {
+        const url = stringField(action, "url");
+        return url ? `Open page: ${url}` : "Open page";
+    }
+    if (actionType === "findInPage") {
+        const pattern = stringField(action, "pattern") ? ` for '${stringField(action, "pattern")}'` : "";
+        const url = stringField(action, "url") ? ` in ${stringField(action, "url")}` : "";
+        return `Find in page${pattern}${url}`.trim();
+    }
+    if (actionType === "other")
+        return "Web search";
+    return "Web search";
+}
+function fileChangeLocations(item) {
+    const locations = fileChangeActions(item)
+        .map((action) => normalizeObject(action))
+        .map((action) => stringField(action, "path"))
+        .filter(Boolean)
+        .map((path) => ({ path }));
+    return locations.length > 0 ? locations : undefined;
+}
+function fileChangeContent(item) {
+    const changes = arrayField(item, "changes") ?? [];
+    const content = changes
+        .map((change) => {
+        const record = normalizeObject(change);
+        if (!record)
+            return null;
+        const path = stringifyToolValue(record.path);
+        const kind = record.kind && typeof record.kind === "object" && !Array.isArray(record.kind)
+            ? stringifyToolValue(record.kind.type)
+            : stringifyToolValue(record.kind);
+        const diff = stringifyToolValue(record.diff);
+        if (kind === "add") {
+            return removeEmpty({
+                type: "diff",
+                oldText: null,
+                newText: diff,
+                path,
+                _meta: { kind: "add" }
+            });
+        }
+        if (kind === "delete") {
+            return removeEmpty({
+                type: "diff",
+                oldText: diff,
+                newText: "",
+                path,
+                _meta: { kind: "delete" }
+            });
+        }
+        return createUpdateFileContent(record, path, diff, kind);
+    })
+        .filter(Boolean);
+    return content.length > 0 ? content : undefined;
+}
+function createUpdateFileContent(change, path, diff, kind) {
+    const movePath = change.kind && typeof change.kind === "object" && !Array.isArray(change.kind)
+        ? stringifyToolValue(change.kind.move_path)
+        : "";
+    const unifiedDiff = recoverCorruptedDiff(diff);
+    const oldContent = readTextFile(path);
+    if (oldContent !== null) {
+        const patchedContent = safeApplyPatch(oldContent, unifiedDiff);
+        if (patchedContent !== false) {
+            return createUpdateDiffContent(movePath || path, oldContent, patchedContent, kind || "update");
+        }
+        const revertedPatch = revertPatch(unifiedDiff);
+        if (revertedPatch) {
+            const revertedContent = safeApplyPatch(oldContent, revertedPatch);
+            if (revertedContent !== false) {
+                return createUpdateDiffContent(path, revertedContent, oldContent, kind || "update");
+            }
+        }
+    }
+    if (movePath) {
+        const newContent = readTextFile(movePath);
+        const revertedPatch = revertPatch(unifiedDiff);
+        if (newContent !== null && revertedPatch) {
+            const revertedContent = safeApplyPatch(newContent, revertedPatch);
+            if (revertedContent !== false) {
+                return createUpdateDiffContent(movePath, revertedContent, newContent, kind || "update");
+            }
+        }
+    }
+    return createUpdateDiffContent(movePath || path, null, unifiedDiff, kind || "update");
+}
+function createUpdateDiffContent(path, oldText, newText, kind) {
+    return removeEmpty({
+        type: "diff",
+        oldText,
+        newText,
+        path,
+        _meta: { kind }
+    });
+}
+function readTextFile(filePath) {
+    try {
+        return readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function recoverCorruptedDiff(diff) {
+    return diff.replace(/\n\nMoved to: .*$/, "");
+}
+function revertPatch(unifiedDiff) {
+    try {
+        const [patch] = parsePatch(unifiedDiff);
+        if (!patch)
+            return null;
+        return reversePatch(patch);
+    }
+    catch {
+        return null;
+    }
+}
+function safeApplyPatch(source, patch) {
+    try {
+        return applyPatch(source, patch);
+    }
+    catch {
+        return false;
+    }
+}
+function toolDisplayName(type, context) {
+    if (type === "commandExecution")
+        return "执行命令";
+    if (type === "fileChange")
+        return context.path ? `编辑文件: ${shortPath(context.path)}` : "编辑文件";
+    if (type === "webSearch")
+        return context.rawInput ? `搜索: ${textPreview(context.rawInput)}` : "搜索";
+    if (type === "mcpToolCall" || type === "dynamicToolCall") {
+        const tool = firstToolString(context.item, ["tool", "name", "server"]);
+        return tool ? `调用工具: ${tool}` : "调用工具";
+    }
+    return labelForItem(type);
+}
+function formatToolOutput(type, aggregatedOutput, item) {
+    if (aggregatedOutput)
+        return aggregatedOutput;
+    if (type === "fileChange") {
+        const fileChange = firstFileChange(item);
+        const filePath = firstToolString(item, ["path", "filePath", "file_path", "relativePath", "absolutePath"]) || fileChange.path;
+        const action = firstToolString(item, ["action", "changeType", "operation"]) || fileChange.action;
+        return [action, filePath].filter(Boolean).join(" ");
+    }
+    return "";
+}
+function firstFileChange(item) {
+    const changes = arrayField(item, "changes") ?? [];
+    for (const change of changes) {
+        if (!change || typeof change !== "object" || Array.isArray(change))
+            continue;
+        const record = change;
+        const path = stringifyToolValue(record.path);
+        const kind = record.kind && typeof record.kind === "object" && !Array.isArray(record.kind)
+            ? stringifyToolValue(record.kind.type)
+            : stringifyToolValue(record.kind);
+        if (path || kind)
+            return { path, action: kind };
+    }
+    return { path: "", action: "" };
+}
+function fileChangeActions(item) {
+    const changes = arrayField(item, "changes") ?? [];
+    return changes
+        .map((change) => {
+        if (!change || typeof change !== "object" || Array.isArray(change))
+            return null;
+        const record = change;
+        const path = stringifyToolValue(record.path);
+        const kind = record.kind && typeof record.kind === "object" && !Array.isArray(record.kind)
+            ? stringifyToolValue(record.kind.type)
+            : stringifyToolValue(record.kind);
+        if (!path && !kind)
+            return null;
+        return removeEmpty({ type: kind || "edit", path });
+    })
+        .filter(Boolean)
+        .slice(0, 50);
+}
+function firstToolString(item, keys) {
+    if (!item)
+        return "";
+    for (const key of keys) {
+        const value = stringifyToolValue(item[key]);
+        if (value)
+            return value;
+    }
+    return "";
+}
+function stringifyToolValue(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value && typeof value === "object") {
+        try {
+            const json = JSON.stringify(value);
+            return json.length > 2 ? json : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+function arrayField(value, key) {
+    const field = value?.[key];
+    return Array.isArray(field) ? field.slice(0, 50) : null;
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => value.trim()) || "";
+}
+function shortPath(value) {
+    return value.replace(/\\/g, "/").split("/").filter(Boolean).pop() || value;
+}
+function removeEmpty(value) {
+    for (const key of Object.keys(value)) {
+        const item = value[key];
+        if (item === undefined || item === "" || (Array.isArray(item) && item.length === 0))
+            delete value[key];
+    }
+    return value;
+}
+function planText(params) {
+    const explanation = stringField(params, "explanation");
+    const plan = Array.isArray(params?.plan) ? params.plan : [];
+    const steps = plan.map((item) => stringField(item, "text")).filter(Boolean);
+    return [explanation, ...steps].filter(Boolean).join("\n") || undefined;
+}
+function objectField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const nested = value[key];
+    if (!nested || typeof nested !== "object" || Array.isArray(nested))
+        return null;
+    return nested;
+}
+function normalizeObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function stringField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return "";
+    const field = value[key];
+    return typeof field === "string" ? field : "";
+}
+function numberField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const field = value[key];
+    return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+function textPreview(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return undefined;
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}