@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.04a1e5b9e484

package/dist/session/provider-cli/provider-output-state.js

@@ -0,0 +1,817 @@
+import { addUsage, emptyUsage, readUsageNumber } from "./provider-usage.js";
+export function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function clip(value, maxLength) {
+    if (maxLength <= 0) {
+        return "";
+    }
+    if (value.length <= maxLength) {
+        return value;
+    }
+    const ellipsis = "...";
+    if (maxLength <= ellipsis.length) {
+        return ellipsis.slice(0, maxLength);
+    }
+    return `${value.slice(0, maxLength - ellipsis.length)}${ellipsis}`;
+}
+export function createProviderOutputState(provider) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === "cursor") {
+        return new CursorStreamJsonState();
+    }
+    if (normalized === "claude") {
+        return new ClaudeStreamJsonState();
+    }
+    return new CodexJsonState();
+}
+class CursorStreamJsonState {
+    sessionId = null;
+    finalMessage = null;
+    emittedSession = false;
+    accumulatedUsage = null;
+    activeToolCallCount = 0;
+    get sessionLabel() {
+        return this.sessionId ? `session ${this.sessionId}` : null;
+    }
+    get providerThreadId() {
+        return this.sessionId;
+    }
+    get usage() {
+        return this.accumulatedUsage;
+    }
+    get hasActiveToolCall() {
+        return this.activeToolCallCount > 0;
+    }
+    consume(line) {
+        const event = parseJsonLine(line);
+        if (!event) {
+            return [];
+        }
+        const type = stringField(event, "type");
+        if (type === "system" && stringField(event, "subtype") === "init") {
+            this.sessionId = stringField(event, "session_id");
+            if (this.sessionId && !this.emittedSession) {
+                this.emittedSession = true;
+                return [{
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: `Cursor session started: ${this.sessionId}.`,
+                        eventType: "provider_thread_started",
+                        data: JSON.stringify({ threadId: this.sessionId })
+                    }];
+            }
+        }
+        if (type === "assistant") {
+            const text = assistantMessageText(event);
+            if (text) {
+                this.finalMessage = text;
+                return [{
+                        role: "assistant",
+                        kind: "message",
+                        content: clip(text, 4000),
+                        eventType: "provider_message"
+                    }];
+            }
+        }
+        if (type === "tool_call") {
+            const subtype = stringField(event, "subtype");
+            const toolCall = objectField(event, "tool_call");
+            if (subtype === "started") {
+                this.activeToolCallCount += 1;
+                const summary = formatCursorToolCallStarted(toolCall);
+                if (summary) {
+                    return [{
+                            role: "worker",
+                            kind: "checkpoint",
+                            content: summary,
+                            eventType: "provider_tool_call"
+                        }];
+                }
+            }
+            if (subtype === "completed") {
+                this.activeToolCallCount = Math.max(0, this.activeToolCallCount - 1);
+                const completed = formatCursorToolCallCompleted(toolCall);
+                if (completed) {
+                    return [{
+                            role: "worker",
+                            kind: completed.kind,
+                            content: completed.content,
+                            eventType: completed.kind === "file_edit" ? "provider_file_edit" : "provider_tool_call"
+                        }];
+                }
+            }
+        }
+        if (type === "result" && stringField(event, "subtype") === "success") {
+            const result = stringField(event, "result");
+            if (result) {
+                this.finalMessage = result;
+            }
+            this.accumulateUsage(event);
+        }
+        if (type === "error" || (type === "result" && event.is_error === true)) {
+            return [{
+                    role: "runner",
+                    kind: "error",
+                    content: clip(line.trim(), 1000),
+                    eventType: "provider_cli_error"
+                }];
+        }
+        return [];
+    }
+    accumulateUsage(event) {
+        const usage = objectField(event, "usage");
+        const durationMs = readUsageNumber(event, "duration_ms") || readUsageNumber(event, "duration_api_ms");
+        if (Object.keys(usage).length === 0 && durationMs === 0) {
+            return;
+        }
+        const uncachedInputTokens = readUsageNumber(usage, "inputTokens");
+        const cacheReadTokens = readUsageNumber(usage, "cacheReadTokens");
+        const cacheCreationTokens = readUsageNumber(usage, "cacheWriteTokens");
+        this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
+            inputTokens: uncachedInputTokens + cacheReadTokens + cacheCreationTokens,
+            uncachedInputTokens,
+            outputTokens: readUsageNumber(usage, "outputTokens"),
+            cacheReadTokens,
+            cacheCreationTokens,
+            providerDurationMs: durationMs > 0 ? durationMs : null,
+            source: "provider_reported",
+            inputTokenSemantics: "excludes_cache_tokens",
+            rawUsage: [{ provider: "cursor", usage }]
+        });
+    }
+}
+function formatCursorToolCallStarted(toolCall) {
+    const readArgs = objectField(objectField(toolCall, "readToolCall"), "args");
+    const readPath = stringField(readArgs, "path");
+    if (readPath) {
+        return `Reading ${readPath}`;
+    }
+    const writeArgs = objectField(objectField(toolCall, "writeToolCall"), "args");
+    const writePath = stringField(writeArgs, "path");
+    if (writePath) {
+        return `Writing ${writePath}`;
+    }
+    const shellArgs = objectField(objectField(toolCall, "shellToolCall"), "args");
+    const command = stringField(shellArgs, "command");
+    if (command) {
+        return `Shell command started: ${clip(command, 500)}`;
+    }
+    const fn = objectField(toolCall, "function");
+    const name = stringField(fn, "name");
+    if (name) {
+        return `Tool call started: ${name}`;
+    }
+    return null;
+}
+function formatCursorToolCallCompleted(toolCall) {
+    const writeArgs = objectField(objectField(toolCall, "writeToolCall"), "args");
+    const writePath = stringField(writeArgs, "path");
+    const writeResult = objectField(objectField(objectField(toolCall, "writeToolCall"), "result"), "success");
+    const writtenPath = stringField(writeResult, "path") ?? writePath;
+    if (writtenPath) {
+        return {
+            kind: "file_edit",
+            content: `Wrote ${writtenPath}`
+        };
+    }
+    const readArgs = objectField(objectField(toolCall, "readToolCall"), "args");
+    const readPath = stringField(readArgs, "path");
+    if (readPath) {
+        const readResult = objectField(objectField(objectField(toolCall, "readToolCall"), "result"), "success");
+        const totalLines = readResult.totalLines;
+        const lineSummary = typeof totalLines === "number" ? ` (${totalLines} lines)` : "";
+        return {
+            kind: "checkpoint",
+            content: `Read ${readPath}${lineSummary}`
+        };
+    }
+    const shellArgs = objectField(objectField(toolCall, "shellToolCall"), "args");
+    const command = stringField(shellArgs, "command");
+    if (command) {
+        return {
+            kind: "checkpoint",
+            content: `Shell command completed: ${clip(command, 500)}`
+        };
+    }
+    const fn = objectField(toolCall, "function");
+    const name = stringField(fn, "name");
+    if (name) {
+        return {
+            kind: "checkpoint",
+            content: `Tool call completed: ${name}`
+        };
+    }
+    return null;
+}
+function assistantMessageText(event) {
+    const message = objectField(event, "message");
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const parts = content
+        .map((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return null;
+        }
+        const block = entry;
+        return stringField(block, "text");
+    })
+        .filter((text) => Boolean(text));
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("");
+}
+export function parseJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : null;
+}
+const claudeFileEditTools = new Set(["edit", "multiedit", "write", "notebookedit"]);
+/**
+ * Parses `claude -p --output-format stream-json --verbose` output. Each line is one of:
+ * `system/init`, `assistant` (text + tool_use blocks), `user` (tool_result blocks), or the
+ * terminal `result` event that carries the aggregated usage for the whole run.
+ */
+class ClaudeStreamJsonState {
+    sessionId = null;
+    finalMessage = null;
+    emittedSession = false;
+    accumulatedUsage = null;
+    activeToolUses = new Map();
+    get sessionLabel() {
+        return this.sessionId ? `session ${this.sessionId}` : null;
+    }
+    get providerThreadId() {
+        return this.sessionId;
+    }
+    get usage() {
+        return this.accumulatedUsage;
+    }
+    get hasActiveToolCall() {
+        return this.activeToolUses.size > 0;
+    }
+    consume(line) {
+        const event = parseJsonLine(line);
+        if (!event) {
+            return [];
+        }
+        const type = stringField(event, "type");
+        if (type === "system" && stringField(event, "subtype") === "init") {
+            return this.consumeInit(event);
+        }
+        if (type === "assistant") {
+            return this.consumeAssistant(event);
+        }
+        if (type === "user") {
+            return this.consumeToolResults(event);
+        }
+        if (type === "result") {
+            return this.consumeResult(event, line);
+        }
+        if (type === "error") {
+            return [providerCliError(line)];
+        }
+        return [];
+    }
+    consumeInit(event) {
+        const events = [];
+        this.sessionId = stringField(event, "session_id") ?? this.sessionId;
+        if (this.sessionId && !this.emittedSession) {
+            this.emittedSession = true;
+            events.push({
+                role: "runner",
+                kind: "checkpoint",
+                content: `Claude session started: ${this.sessionId}.`,
+                eventType: "provider_thread_started"
+            });
+        }
+        const servers = Array.isArray(event.mcp_servers) ? event.mcp_servers : [];
+        for (const entry of servers) {
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const server = entry;
+            const name = stringField(server, "name");
+            const status = stringField(server, "status");
+            if (name && status && status !== "connected") {
+                events.push({
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: `Claude MCP server ${name} is ${status}.`,
+                    eventType: "provider_mcp_server_status",
+                    data: JSON.stringify({ server_name: name, status })
+                });
+            }
+        }
+        return events;
+    }
+    consumeAssistant(event) {
+        const events = [];
+        const text = assistantMessageText(event);
+        if (text) {
+            this.finalMessage = text;
+            events.push({
+                role: "assistant",
+                kind: "message",
+                content: clip(text, 4000),
+                eventType: "provider_message"
+            });
+        }
+        for (const block of messageContentBlocks(event)) {
+            if (stringField(block, "type") !== "tool_use") {
+                continue;
+            }
+            const id = stringField(block, "id");
+            const name = stringField(block, "name");
+            if (!id || !name) {
+                continue;
+            }
+            const toolUse = { name, input: objectField(block, "input") };
+            this.activeToolUses.set(id, toolUse);
+            events.push(...formatClaudeToolUseStarted(toolUse));
+        }
+        return events;
+    }
+    consumeToolResults(event) {
+        const events = [];
+        for (const block of messageContentBlocks(event)) {
+            if (stringField(block, "type") !== "tool_result") {
+                continue;
+            }
+            const id = stringField(block, "tool_use_id");
+            const toolUse = id ? this.activeToolUses.get(id) : undefined;
+            if (!id || !toolUse) {
+                continue;
+            }
+            this.activeToolUses.delete(id);
+            events.push(...formatClaudeToolUseCompleted(toolUse, block.is_error === true, toolResultText(block)));
+        }
+        return events;
+    }
+    consumeResult(event, line) {
+        this.activeToolUses.clear();
+        this.accumulateUsage(event);
+        const result = stringField(event, "result");
+        const subtype = stringField(event, "subtype") ?? "";
+        const failed = event.is_error === true || subtype.startsWith("error");
+        if (!failed) {
+            if (result) {
+                this.finalMessage = result;
+            }
+            return [{
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: "Claude turn completed.",
+                    eventType: "provider_turn_completed"
+                }];
+        }
+        return [providerCliError(line)];
+    }
+    accumulateUsage(event) {
+        const usage = objectField(event, "usage");
+        const durationMs = readUsageNumber(event, "duration_ms") || readUsageNumber(event, "duration_api_ms");
+        if (Object.keys(usage).length === 0 && durationMs === 0) {
+            return;
+        }
+        // Anthropic's input_tokens excludes cache reads and writes; normalize to a cache-inclusive total.
+        const uncachedInputTokens = readUsageNumber(usage, "input_tokens");
+        const cacheReadTokens = readUsageNumber(usage, "cache_read_input_tokens");
+        const cacheCreationTokens = readUsageNumber(usage, "cache_creation_input_tokens");
+        this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
+            inputTokens: uncachedInputTokens + cacheReadTokens + cacheCreationTokens,
+            uncachedInputTokens,
+            outputTokens: readUsageNumber(usage, "output_tokens"),
+            cacheReadTokens,
+            cacheCreationTokens,
+            providerDurationMs: durationMs > 0 ? durationMs : null,
+            source: "provider_reported",
+            inputTokenSemantics: "excludes_cache_tokens",
+            rawUsage: [{ provider: "claude", usage }]
+        });
+    }
+}
+function providerCliError(line) {
+    return {
+        role: "runner",
+        kind: "error",
+        content: clip(line.trim(), 1000),
+        eventType: "provider_cli_error"
+    };
+}
+function messageContentBlocks(event) {
+    const content = objectField(event, "message").content;
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry));
+}
+function toolResultText(block) {
+    const content = block.content;
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .map((entry) => entry && typeof entry === "object" ? stringField(entry, "text") : null)
+        .filter((part) => Boolean(part))
+        .join("\n")
+        .trim();
+    return text || null;
+}
+/**
+ * Claude Code exposes MCP tools as `mcp__<server>__<tool>` and replaces characters outside
+ * `[A-Za-z0-9_-]` with `_`, so `forge.complete_qa` arrives as `mcp__forge__forge_complete_qa`.
+ */
+export function parseClaudeMcpToolName(name) {
+    const match = /^mcp__(.+?)__(.+)$/u.exec(name);
+    if (!match) {
+        return null;
+    }
+    const server = match[1] ?? "";
+    const rawTool = match[2] ?? "";
+    const tool = server === "forge" && rawTool.startsWith("forge_") ? `forge.${rawTool.slice("forge_".length)}` : rawTool;
+    return server && tool ? { server, tool } : null;
+}
+function claudeMcpEvents(toolUse, phase, errorText) {
+    const mcp = parseClaudeMcpToolName(toolUse.name);
+    if (!mcp) {
+        return null;
+    }
+    const item = {
+        type: "mcp_tool_call",
+        server: mcp.server,
+        tool: mcp.tool,
+        status: phase
+    };
+    if (phase === "failed") {
+        item.error = errorText ? clip(errorText, 600) : "MCP tool call failed.";
+    }
+    return formatCodexMcpToolCallEvents(phase === "started" ? "item.started" : "item.completed", { item });
+}
+function formatClaudeToolUseStarted(toolUse) {
+    const mcp = claudeMcpEvents(toolUse, "started", null);
+    if (mcp) {
+        return mcp;
+    }
+    const normalized = toolUse.name.toLowerCase();
+    const filePath = stringField(toolUse.input, "file_path") ?? stringField(toolUse.input, "notebook_path") ?? stringField(toolUse.input, "path");
+    let content;
+    if (normalized === "bash") {
+        const command = stringField(toolUse.input, "command");
+        content = command ? `Shell command started: ${clip(command, 500)}` : "Shell command started.";
+    }
+    else if (normalized === "read" && filePath) {
+        content = `Reading ${filePath}`;
+    }
+    else if (claudeFileEditTools.has(normalized) && filePath) {
+        content = `Writing ${filePath}`;
+    }
+    else {
+        content = `Tool call started: ${toolUse.name}`;
+    }
+    return [{
+            role: "worker",
+            kind: "checkpoint",
+            content,
+            eventType: normalized === "bash" ? "provider_command" : "provider_tool_call"
+        }];
+}
+function formatClaudeToolUseCompleted(toolUse, isError, resultText) {
+    const mcp = claudeMcpEvents(toolUse, isError ? "failed" : "completed", resultText);
+    if (mcp) {
+        return mcp;
+    }
+    const normalized = toolUse.name.toLowerCase();
+    const filePath = stringField(toolUse.input, "file_path") ?? stringField(toolUse.input, "notebook_path") ?? stringField(toolUse.input, "path");
+    if (claudeFileEditTools.has(normalized) && filePath && !isError) {
+        return [{
+                role: "worker",
+                kind: "file_edit",
+                content: `Wrote ${filePath}`,
+                eventType: "provider_file_edit"
+            }];
+    }
+    const status = isError ? "failed" : "completed";
+    let content;
+    if (normalized === "bash") {
+        const command = stringField(toolUse.input, "command");
+        content = command ? `Shell command ${status}: ${clip(command, 500)}` : `Shell command ${status}.`;
+    }
+    else if (normalized === "read" && filePath) {
+        content = isError ? `Read failed: ${filePath}` : `Read ${filePath}`;
+    }
+    else {
+        content = `Tool call ${status}: ${toolUse.name}`;
+    }
+    return [{
+            role: "worker",
+            kind: "checkpoint",
+            content,
+            eventType: normalized === "bash" ? "provider_command" : "provider_tool_call"
+        }];
+}
+class CodexJsonState {
+    threadId = null;
+    finalMessage = null;
+    emittedThread = false;
+    accumulatedUsage = null;
+    activeToolCallCount = 0;
+    get sessionLabel() {
+        return this.threadId ? `thread ${this.threadId}` : null;
+    }
+    get providerThreadId() {
+        return this.threadId;
+    }
+    get usage() {
+        return this.accumulatedUsage;
+    }
+    get hasActiveToolCall() {
+        return this.activeToolCallCount > 0;
+    }
+    consume(line) {
+        const event = parseJsonLine(line);
+        if (!event) {
+            return [];
+        }
+        const type = stringField(event, "type") ?? "";
+        this.trackToolActivity(type, event);
+        if (type === "thread.started") {
+            this.threadId = stringField(event, "thread_id");
+            if (this.threadId && !this.emittedThread) {
+                this.emittedThread = true;
+                return [{
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: `Codex thread started: ${this.threadId}.`,
+                        eventType: "provider_thread_started",
+                        data: JSON.stringify({ threadId: this.threadId })
+                    }];
+            }
+        }
+        if (type === "turn.completed") {
+            this.accumulateUsage(event);
+            return [{
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: "Codex turn completed.",
+                    eventType: "provider_turn_completed"
+                }];
+        }
+        if (type === "turn.failed" || type === "error") {
+            return [{
+                    role: "runner",
+                    kind: "error",
+                    content: clip(line.trim(), 1000),
+                    eventType: "provider_cli_error"
+                }];
+        }
+        if (type === "item.started" || type === "item.completed" || type === "item.updated") {
+            const item = objectField(event, "item");
+            const itemType = stringField(item, "type");
+            if (itemType === "agent_message") {
+                const text = stringField(item, "text");
+                if (text) {
+                    this.finalMessage = text;
+                    return [{
+                            role: "assistant",
+                            kind: "message",
+                            content: clip(text, 4000),
+                            eventType: "provider_message"
+                        }];
+                }
+            }
+            if (itemType === "command_execution") {
+                const command = stringField(item, "command");
+                const status = stringField(item, "status");
+                if (command) {
+                    return [{
+                            role: "worker",
+                            kind: "checkpoint",
+                            content: `Codex command ${status || (type === "item.started" ? "started" : "completed")}: ${clip(command, 500)}`,
+                            eventType: "provider_command"
+                        }];
+                }
+            }
+        }
+        const mcpEvents = formatCodexMcpToolCallEvents(type, event);
+        if (mcpEvents.length > 0) {
+            return mcpEvents;
+        }
+        return [];
+    }
+    trackToolActivity(type, event) {
+        if (type !== "item.started" && type !== "item.completed") {
+            return;
+        }
+        const item = objectField(event, "item");
+        const itemType = (stringField(item, "type") ?? "").toLowerCase();
+        const toolName = mcpToolName(item);
+        const isTool = itemType === "command_execution"
+            || itemType.includes("mcp")
+            || Boolean(toolName);
+        if (!isTool) {
+            return;
+        }
+        this.activeToolCallCount = type === "item.started"
+            ? this.activeToolCallCount + 1
+            : Math.max(0, this.activeToolCallCount - 1);
+    }
+    accumulateUsage(event) {
+        const usage = objectField(event, "usage");
+        if (Object.keys(usage).length === 0) {
+            return;
+        }
+        const inputTokens = readUsageNumber(usage, "input_tokens");
+        const cacheReadTokens = readUsageNumber(usage, "cached_input_tokens");
+        this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
+            inputTokens,
+            uncachedInputTokens: Math.max(0, inputTokens - cacheReadTokens),
+            outputTokens: readUsageNumber(usage, "output_tokens"),
+            cacheReadTokens,
+            reasoningOutputTokens: readUsageNumber(usage, "reasoning_output_tokens"),
+            source: "provider_reported",
+            inputTokenSemantics: "includes_cached_input",
+            rawUsage: [{ provider: "codex", usage }]
+        });
+    }
+}
+export function formatCodexMcpToolCallEvents(type, event) {
+    if (type !== "item.started" && type !== "item.updated" && type !== "item.completed") {
+        return [];
+    }
+    const item = objectField(event, "item");
+    const itemType = stringField(item, "type") ?? "";
+    const serverName = mcpServerName(item);
+    const toolName = mcpToolName(item);
+    const isMcpItem = itemType.toLowerCase().includes("mcp")
+        || Boolean(serverName)
+        || (toolName ? isForgeCompletionTool(toolName) || toolName.toLowerCase().includes("mcp") : false);
+    if (!isMcpItem || !toolName) {
+        return [];
+    }
+    const status = normalizedString(stringField(item, "status")
+        ?? stringField(event, "status")
+        ?? (type === "item.started" ? "started" : type === "item.completed" ? "completed" : "updated"));
+    const failed = status === "failed" || status === "error" || status === "cancelled" || Boolean(item.error);
+    const completed = failed || type === "item.completed" || status === "completed" || status === "succeeded" || status === "success";
+    const started = type === "item.started" || status === "started" || status === "running" || status === "in_progress";
+    const data = safeProviderMcpData(item, serverName ?? "unknown", toolName, status);
+    const label = `${serverName ?? "unknown"}.${toolName}`;
+    if (failed) {
+        const summary = mcpErrorSummary(item) ?? "MCP tool call failed.";
+        const events = [{
+                role: "tool",
+                kind: "error",
+                content: `MCP tool call failed: ${label} - ${summary}`,
+                eventType: "provider_mcp_call_failed",
+                data
+            }];
+        if (isForgeCompletionTool(toolName)) {
+            events.push({
+                role: "tool",
+                kind: "error",
+                content: `Forge completion tool validation failed: ${label} - ${summary}`,
+                eventType: "completion_tool_validation_failed",
+                data
+            });
+        }
+        return events;
+    }
+    if (completed) {
+        return [{
+                role: "tool",
+                kind: "checkpoint",
+                content: `MCP tool call completed: ${label}.`,
+                eventType: "provider_mcp_call_completed",
+                data
+            }];
+    }
+    if (started) {
+        return [{
+                role: "tool",
+                kind: "checkpoint",
+                content: `MCP tool call started: ${label}.`,
+                eventType: "provider_mcp_call_started",
+                data
+            }];
+    }
+    return [];
+}
+function mcpServerName(item) {
+    return stringField(item, "server")
+        ?? stringField(item, "server_name")
+        ?? stringField(item, "mcp_server")
+        ?? stringField(objectField(item, "mcp"), "server")
+        ?? stringField(objectField(item, "mcp"), "server_name");
+}
+function mcpToolName(item) {
+    return stringField(item, "tool")
+        ?? stringField(item, "tool_name")
+        ?? stringField(item, "name")
+        ?? stringField(objectField(item, "function"), "name")
+        ?? stringField(objectField(item, "mcp"), "tool")
+        ?? stringField(objectField(item, "mcp"), "tool_name");
+}
+function mcpErrorSummary(item) {
+    const direct = stringField(item, "error")
+        ?? stringField(item, "error_message")
+        ?? stringField(item, "message");
+    if (direct) {
+        return clip(direct, 600);
+    }
+    const messages = uniqueErrorMessages([
+        item.error,
+        item.result,
+        item.content,
+    ]);
+    return messages.length > 0 ? clip(messages.join(" Caused by: "), 600) : null;
+}
+function uniqueErrorMessages(values) {
+    const messages = [];
+    const seenMessages = new Set();
+    const seenObjects = new Set();
+    const visit = (value, depth) => {
+        if (depth > 8 || value === null || value === undefined)
+            return;
+        if (typeof value === "string") {
+            const message = value.trim();
+            if (message.length > 0 && !seenMessages.has(message)) {
+                seenMessages.add(message);
+                messages.push(message);
+            }
+            return;
+        }
+        if (typeof value !== "object" || seenObjects.has(value))
+            return;
+        seenObjects.add(value);
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                visit(entry, depth + 1);
+            return;
+        }
+        const record = value;
+        for (const key of ["message", "summary", "error", "cause", "data", "details", "result", "content"]) {
+            if (key in record)
+                visit(record[key], depth + 1);
+        }
+    };
+    for (const value of values)
+        visit(value, 0);
+    return messages;
+}
+function safeProviderMcpData(item, serverName, toolName, status) {
+    const elapsedMs = numericField(item, "elapsed_ms") ?? numericField(item, "duration_ms");
+    return JSON.stringify(stripUndefined({
+        server_name: serverName,
+        tool_name: toolName,
+        status,
+        elapsed_ms: elapsedMs,
+        error_summary: mcpErrorSummary(item)
+    }));
+}
+function isForgeCompletionTool(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    return normalized.startsWith("forge.complete_")
+        || normalized.startsWith("complete_")
+        || normalized.includes("forge.complete_")
+        || normalized.includes("complete_architect_plan");
+}
+export function objectField(source, key) {
+    const value = source[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function stringField(source, key) {
+    const value = source[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+export function numericField(source, key) {
+    const value = source[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+export function normalizedString(value) {
+    return value.trim().toLowerCase().replace(/-/g, "_");
+}
+export function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}