claude-code-rust 0.9.0 → 0.10.0

package/agent-sdk/dist/bridge/tool_calls.js

@@ -1,13 +1,177 @@
 import { emitSessionUpdate } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { buildToolResultFields, createToolCall } from "./tooling.js";
+function jsonSize(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        return Buffer.byteLength(JSON.stringify(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function toolNameFromMeta(meta) {
+    if (!meta || typeof meta !== "object") {
+        return undefined;
+    }
+    const claudeCode = "claudeCode" in meta && meta.claudeCode && typeof meta.claudeCode === "object" ? meta.claudeCode : undefined;
+    const toolName = claudeCode && "toolName" in claudeCode && typeof claudeCode.toolName === "string" ? claudeCode.toolName : "";
+    return toolName || undefined;
+}
+function toolName(base, fields) {
+    const fieldMeta = fields?.meta;
+    if (fieldMeta && typeof fieldMeta === "object") {
+        const fromFields = toolNameFromMeta(fieldMeta);
+        if (fromFields) {
+            return fromFields;
+        }
+    }
+    return toolNameFromMeta(base?.meta);
+}
+function classifyFailureKind(rawOutput) {
+    if (!rawOutput) {
+        return "failed";
+    }
+    const normalized = rawOutput.trim().toLowerCase();
+    if (normalized.includes("permission denied") ||
+        normalized.includes("cancelled by user") ||
+        normalized.includes("plan rejected") ||
+        normalized.includes("question cancelled")) {
+        return "refused";
+    }
+    if (normalized.includes("timed out") || normalized.includes("timeout")) {
+        return "timeout";
+    }
+    return "failed";
+}
+function updateOutcome(status) {
+    switch (status) {
+        case "completed":
+            return "success";
+        case "failed":
+            return "failure";
+        case "in_progress":
+            return "partial";
+        case "pending":
+            return "start";
+        default:
+            return "partial";
+    }
+}
+function applyFieldsToBase(base, fields) {
+    if (fields.title !== undefined) {
+        base.title = fields.title;
+    }
+    if (fields.kind !== undefined) {
+        base.kind = fields.kind;
+    }
+    if (fields.status !== undefined) {
+        base.status = fields.status;
+    }
+    if (fields.raw_input !== undefined) {
+        base.raw_input = fields.raw_input;
+    }
+    if (fields.raw_output !== undefined) {
+        base.raw_output = fields.raw_output;
+    }
+    if (fields.locations !== undefined) {
+        base.locations = fields.locations;
+    }
+    if (fields.output_metadata !== undefined) {
+        base.output_metadata = fields.output_metadata;
+    }
+    if (fields.meta !== undefined) {
+        base.meta = fields.meta;
+    }
+    if (fields.content !== undefined) {
+        base.content = fields.content;
+    }
+}
+function logToolCallSubmitted(sessionId, toolCall, updateKind) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_TOOL,
+        eventName: "tool_call_submitted",
+        message: "tool call submitted",
+        outcome: "success",
+        sessionId,
+        toolCallId: toolCall.tool_call_id,
+        sizeBytes: jsonSize(toolCall.raw_input),
+        fields: {
+            submission_kind: updateKind,
+            tool_name: toolNameFromMeta(toolCall.meta),
+            tool_title: toolCall.title,
+            tool_kind: toolCall.kind,
+            status: toolCall.status,
+            content_block_count: toolCall.content.length,
+            location_count: toolCall.locations.length,
+            has_output_metadata: toolCall.output_metadata !== undefined,
+        },
+    });
+}
+function logToolCallUpdateEmitted(sessionId, toolUseId, fields, base, updateKind) {
+    const nextStatus = fields.status ?? base?.status;
+    const rawOutput = typeof fields.raw_output === "string" ? fields.raw_output : base?.raw_output;
+    const failureKind = nextStatus === "failed" ? classifyFailureKind(rawOutput) : undefined;
+    const commonEvent = {
+        target: LOG_TARGETS.APP_TOOL,
+        eventName: "tool_call_update_emitted",
+        message: "tool call update emitted",
+        outcome: updateOutcome(nextStatus),
+        sessionId,
+        toolCallId: toolUseId,
+        sizeBytes: jsonSize(fields.raw_input),
+        fields: {
+            update_kind: updateKind,
+            tool_name: toolName(base, fields),
+            previous_status: base?.status,
+            next_status: nextStatus,
+            title_changed: fields.title !== undefined && fields.title !== base?.title,
+            content_block_count: fields.content?.length,
+            location_count: fields.locations?.length,
+            raw_output_chars: rawOutput?.length,
+            has_output_metadata: fields.output_metadata !== undefined || base?.output_metadata !== undefined,
+            failure_kind: failureKind,
+        },
+    };
+    if (nextStatus === "failed") {
+        bridgeLogger.warn(commonEvent);
+        return;
+    }
+    if (nextStatus === "completed") {
+        bridgeLogger.info(commonEvent);
+        return;
+    }
+    if (nextStatus === "in_progress" || nextStatus === "pending") {
+        bridgeLogger.debug(commonEvent);
+        return;
+    }
+    bridgeLogger.debug(commonEvent);
+}
+function emitInitialToolCall(session, toolCall, updateKind = "initial") {
+    session.toolCalls.set(toolCall.tool_call_id, toolCall);
+    logToolCallSubmitted(session.sessionId, toolCall, updateKind);
+    emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: toolCall });
+}
+export function emitToolCallUpdate(session, toolUseId, fields, updateKind) {
+    const base = session.toolCalls.get(toolUseId);
+    logToolCallUpdateEmitted(session.sessionId, toolUseId, fields, base, updateKind);
+    emitSessionUpdate(session.sessionId, {
+        type: "tool_call_update",
+        tool_call_update: { tool_call_id: toolUseId, fields },
+    });
+    if (base) {
+        applyFieldsToBase(base, fields);
+    }
+}
 export function emitToolCall(session, toolUseId, name, input) {
     const toolCall = createToolCall(toolUseId, name, input);
     const status = "in_progress";
     toolCall.status = status;
     const existing = session.toolCalls.get(toolUseId);
     if (!existing) {
-        session.toolCalls.set(toolUseId, toolCall);
-        emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: toolCall });
+        emitInitialToolCall(session, toolCall);
         return;
     }
     const fields = {
@@ -21,19 +185,7 @@ export function emitToolCall(session, toolUseId, name, input) {
     if (toolCall.content.length > 0) {
         fields.content = toolCall.content;
     }
-    emitSessionUpdate(session.sessionId, {
-        type: "tool_call_update",
-        tool_call_update: { tool_call_id: toolUseId, fields },
-    });
-    existing.title = toolCall.title;
-    existing.kind = toolCall.kind;
-    existing.status = status;
-    existing.raw_input = toolCall.raw_input;
-    existing.locations = toolCall.locations;
-    existing.meta = toolCall.meta;
-    if (toolCall.content.length > 0) {
-        existing.content = toolCall.content;
-    }
+    emitToolCallUpdate(session, toolUseId, fields, "refresh");
 }
 export function ensureToolCallVisible(session, toolUseId, toolName, input) {
     const existing = session.toolCalls.get(toolUseId);
@@ -41,8 +193,7 @@ export function ensureToolCallVisible(session, toolUseId, toolName, input) {
         return existing;
     }
     const toolCall = createToolCall(toolUseId, toolName, input);
-    session.toolCalls.set(toolUseId, toolCall);
-    emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: toolCall });
+    emitInitialToolCall(session, toolCall);
     return toolCall;
 }
 export function emitPlanIfTodoWrite(session, name, input) {
@@ -68,34 +219,15 @@ export function emitPlanIfTodoWrite(session, name, input) {
     }
 }
 export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent) {
-    const base = session.toolCalls.get(toolUseId);
-    const fields = buildToolResultFields(isError, rawContent, base, rawResult);
-    const update = { tool_call_id: toolUseId, fields };
-    emitSessionUpdate(session.sessionId, { type: "tool_call_update", tool_call_update: update });
-    if (base) {
-        base.status = fields.status ?? base.status;
-        if (fields.raw_output) {
-            base.raw_output = fields.raw_output;
-        }
-        if (fields.content) {
-            base.content = fields.content;
-        }
-        if (fields.output_metadata) {
-            base.output_metadata = fields.output_metadata;
-        }
-    }
+    const fields = buildToolResultFields(isError, rawContent, session.toolCalls.get(toolUseId), rawResult);
+    emitToolCallUpdate(session, toolUseId, fields, "result");
 }
 export function finalizeOpenToolCalls(session, status) {
     for (const [toolUseId, toolCall] of session.toolCalls) {
         if (toolCall.status !== "pending" && toolCall.status !== "in_progress") {
             continue;
         }
-        const fields = { status };
-        emitSessionUpdate(session.sessionId, {
-            type: "tool_call_update",
-            tool_call_update: { tool_call_id: toolUseId, fields },
-        });
-        toolCall.status = status;
+        emitToolCallUpdate(session, toolUseId, { status }, "finalize");
     }
 }
 export function emitToolProgressUpdate(session, toolUseId, toolName) {
@@ -109,12 +241,7 @@ export function emitToolProgressUpdate(session, toolUseId, toolName) {
         existing.status === "failed") {
         return;
     }
-    const fields = { status: "in_progress" };
-    emitSessionUpdate(session.sessionId, {
-        type: "tool_call_update",
-        tool_call_update: { tool_call_id: toolUseId, fields },
-    });
-    existing.status = "in_progress";
+    emitToolCallUpdate(session, toolUseId, { status: "in_progress" }, "progress");
 }
 export function emitToolSummaryUpdate(session, toolUseId, summary) {
     const base = session.toolCalls.get(toolUseId);
@@ -126,12 +253,7 @@ export function emitToolSummaryUpdate(session, toolUseId, summary) {
         raw_output: summary,
         content: [{ type: "content", content: { type: "text", text: summary } }],
     };
-    emitSessionUpdate(session.sessionId, {
-        type: "tool_call_update",
-        tool_call_update: { tool_call_id: toolUseId, fields },
-    });
-    base.status = fields.status ?? base.status;
-    base.raw_output = summary;
+    emitToolCallUpdate(session, toolUseId, fields, "summary");
 }
 export function setToolCallStatus(session, toolUseId, status, message) {
     const base = session.toolCalls.get(toolUseId);
@@ -143,14 +265,7 @@ export function setToolCallStatus(session, toolUseId, status, message) {
         fields.raw_output = message;
         fields.content = [{ type: "content", content: { type: "text", text: message } }];
     }
-    emitSessionUpdate(session.sessionId, {
-        type: "tool_call_update",
-        tool_call_update: { tool_call_id: toolUseId, fields },
-    });
-    base.status = status;
-    if (fields.raw_output) {
-        base.raw_output = fields.raw_output;
-    }
+    emitToolCallUpdate(session, toolUseId, fields, "status");
 }
 export function resolveTaskToolUseId(session, msg) {
     const direct = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";

package/agent-sdk/dist/bridge/user_interaction.js

@@ -1,6 +1,7 @@
 import { asRecordOrNull } from "./shared.js";
-import { writeEvent, emitSessionUpdate } from "./events.js";
-import { setToolCallStatus } from "./tool_calls.js";
+import { emitPermissionRequestEvent, emitQuestionRequestEvent, } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
+import { emitToolCallUpdate, setToolCallStatus } from "./tool_calls.js";
 export const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
 export const QUESTION_CHOICE_KIND = "question_choice";
 export const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
@@ -31,7 +32,20 @@ export async function requestExitPlanModeApproval(session, toolUseId, inputData,
             toolName: EXIT_PLAN_MODE_TOOL_NAME,
             inputData,
         });
-        writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_request_created",
+            message: "exit plan mode permission request created",
+            outcome: "start",
+            sessionId: session.sessionId,
+            toolCallId: toolUseId,
+            count: request.options.length,
+            fields: {
+                tool_name: EXIT_PLAN_MODE_TOOL_NAME,
+                option_count: request.options.length,
+            },
+        });
+        emitPermissionRequestEvent(session.sessionId, request);
     });
     if (outcome.outcome !== "selected" || outcome.option_id === "reject") {
         setToolCallStatus(session, toolUseId, "failed", "Plan rejected");
@@ -159,16 +173,7 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, inputDat
             status: "in_progress",
             raw_input: promptToolCall.raw_input,
         };
-        emitSessionUpdate(session.sessionId, {
-            type: "tool_call_update",
-            tool_call_update: { tool_call_id: toolUseId, fields },
-        });
-        const tracked = session.toolCalls.get(toolUseId);
-        if (tracked) {
-            tracked.title = promptToolCall.title;
-            tracked.status = "in_progress";
-            tracked.raw_input = promptToolCall.raw_input;
-        }
+        emitToolCallUpdate(session, toolUseId, fields, "status");
         const request = buildQuestionRequest(promptToolCall, prompt, index, prompts.length);
         const outcome = await new Promise((resolve) => {
             session.pendingQuestions.set(toolUseId, {
@@ -176,7 +181,21 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, inputDat
                 toolName: ASK_USER_QUESTION_TOOL_NAME,
                 inputData,
             });
-            writeEvent({ event: "question_request", session_id: session.sessionId, request });
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_PERMISSION,
+                eventName: "question_request_created",
+                message: "ask user question request created",
+                outcome: "start",
+                sessionId: session.sessionId,
+                toolCallId: toolUseId,
+                count: request.prompt.options.length,
+                fields: {
+                    tool_name: ASK_USER_QUESTION_TOOL_NAME,
+                    question_index: index,
+                    total_questions: prompts.length,
+                },
+            });
+            emitQuestionRequestEvent(session.sessionId, request);
         });
         if (outcome.outcome !== "answered") {
             setToolCallStatus(session, toolUseId, "failed", "Question cancelled");
@@ -201,15 +220,7 @@ export async function requestAskUserQuestionAnswers(session, toolUseId, inputDat
             raw_output: summary,
             content: [{ type: "content", content: { type: "text", text: summary } }],
         };
-        emitSessionUpdate(session.sessionId, {
-            type: "tool_call_update",
-            tool_call_update: { tool_call_id: toolUseId, fields: progressFields },
-        });
-        if (tracked) {
-            tracked.status = progressFields.status ?? tracked.status;
-            tracked.raw_output = summary;
-            tracked.content = progressFields.content ?? tracked.content;
-        }
+        emitToolCallUpdate(session, toolUseId, progressFields, "summary");
     }
     return {
         behavior: "allow",