claude-code-rust 0.9.0 → 0.11.0

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

@@ -46,10 +46,3 @@ export class AsyncQueue {
         };
     }
 }
-const permissionDebugEnabled = process.env.CLAUDE_RS_SDK_PERMISSION_DEBUG === "1" || process.env.CLAUDE_RS_SDK_DEBUG === "1";
-export function logPermissionDebug(message) {
-    if (!permissionDebugEnabled) {
-        return;
-    }
-    console.error(`[perm debug] ${message}`);
-}

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

@@ -20,6 +20,25 @@ export function parseRateLimitStatus(value) {
     }
     return null;
 }
+export function parseRuntimeSessionState(value) {
+    if (value === "idle" || value === "running" || value === "requires_action") {
+        return value;
+    }
+    return null;
+}
+export function parseApiRetryError(value) {
+    switch (value) {
+        case "authentication_failed":
+        case "billing_error":
+        case "rate_limit":
+        case "invalid_request":
+        case "server_error":
+        case "max_output_tokens":
+            return value;
+        default:
+            return "unknown";
+    }
+}
 export function buildRateLimitUpdate(rateLimitInfo) {
     const info = asRecordOrNull(rateLimitInfo);
     if (!info) {
@@ -64,3 +83,45 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     }
     return update;
 }
+export function buildApiRetryUpdate(message) {
+    const attempt = numberField(message, "attempt");
+    const maxRetries = numberField(message, "max_retries", "maxRetries");
+    const retryDelayMs = numberField(message, "retry_delay_ms", "retryDelayMs");
+    if (attempt === undefined || maxRetries === undefined || retryDelayMs === undefined) {
+        return null;
+    }
+    const rawStatus = message.error_status ?? message.errorStatus;
+    const errorStatus = typeof rawStatus === "number" && Number.isFinite(rawStatus) ? rawStatus : null;
+    return {
+        type: "api_retry_update",
+        attempt,
+        max_retries: maxRetries,
+        retry_delay_ms: retryDelayMs,
+        error_status: errorStatus,
+        error: parseApiRetryError(message.error),
+    };
+}
+export function normalizeSettingsParseError(value) {
+    const record = asRecordOrNull(value);
+    if (!record) {
+        return null;
+    }
+    const message = typeof record.message === "string" ? record.message.trim() : "";
+    if (!message) {
+        return null;
+    }
+    const path = typeof record.path === "string" ? record.path : "";
+    const file = typeof record.file === "string" && record.file.trim() ? record.file : undefined;
+    return {
+        ...(file ? { file } : {}),
+        path,
+        message,
+    };
+}
+export function normalizeSettingsParseErrors(value) {
+    const entries = Array.isArray(value) ? value : [value];
+    return entries.flatMap((entry) => {
+        const normalized = normalizeSettingsParseError(entry);
+        return normalized ? [normalized] : [];
+    });
+}

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

@@ -1,13 +1,202 @@
 import { emitSessionUpdate } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { buildToolResultFields, createToolCall } from "./tooling.js";
-export function emitToolCall(session, toolUseId, name, input) {
-    const toolCall = createToolCall(toolUseId, name, input);
+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":
+        case "killed":
+            return "failure";
+        case "in_progress":
+            return "partial";
+        case "pending":
+            return "start";
+        default:
+            return "partial";
+    }
+}
+function parentToolUseIdFromMeta(meta) {
+    if (!meta || typeof meta !== "object") {
+        return null;
+    }
+    const claudeCode = "claudeCode" in meta && meta.claudeCode && typeof meta.claudeCode === "object" ? meta.claudeCode : undefined;
+    const parentToolUseId = claudeCode && "parentToolUseId" in claudeCode && typeof claudeCode.parentToolUseId === "string"
+        ? claudeCode.parentToolUseId
+        : null;
+    return parentToolUseId;
+}
+function mergeTaskMetadata(current, update) {
+    if (update === undefined) {
+        return current;
+    }
+    return {
+        ...(current ?? {}),
+        ...update,
+    };
+}
+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.task_metadata !== undefined) {
+        base.task_metadata = mergeTaskMetadata(base.task_metadata, fields.task_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,
+            has_task_metadata: fields.task_metadata !== undefined || base?.task_metadata !== undefined,
+            failure_kind: failureKind,
+        },
+    };
+    if (nextStatus === "failed" || nextStatus === "killed") {
+        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, parentToolUseId = null) {
+    const existing = session.toolCalls.get(toolUseId);
+    const resolvedParentToolUseId = parentToolUseId ?? parentToolUseIdFromMeta(existing?.meta);
+    const toolCall = createToolCall(toolUseId, name, input, resolvedParentToolUseId);
     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,28 +210,20 @@ 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) {
+export function ensureToolCallVisible(session, toolUseId, toolName, input, parentToolUseId = null) {
     const existing = session.toolCalls.get(toolUseId);
     if (existing) {
+        const existingParentToolUseId = parentToolUseIdFromMeta(existing.meta);
+        if (parentToolUseId && existingParentToolUseId !== parentToolUseId) {
+            const refreshed = createToolCall(toolUseId, toolName, input, parentToolUseId);
+            emitToolCallUpdate(session, toolUseId, { meta: refreshed.meta }, "refresh");
+        }
         return existing;
     }
-    const toolCall = createToolCall(toolUseId, toolName, input);
-    session.toolCalls.set(toolUseId, toolCall);
-    emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: toolCall });
+    const toolCall = createToolCall(toolUseId, toolName, input, parentToolUseId);
+    emitInitialToolCall(session, toolCall);
     return toolCall;
 }
 export function emitPlanIfTodoWrite(session, name, input) {
@@ -68,34 +249,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) {
@@ -106,15 +268,11 @@ export function emitToolProgressUpdate(session, toolUseId, toolName) {
     }
     if (existing.status === "in_progress" ||
         existing.status === "completed" ||
-        existing.status === "failed") {
+        existing.status === "failed" ||
+        existing.status === "killed") {
         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);
@@ -122,16 +280,11 @@ export function emitToolSummaryUpdate(session, toolUseId, summary) {
         return;
     }
     const fields = {
-        status: base.status === "failed" ? "failed" : "completed",
+        status: base.status === "failed" || base.status === "killed" ? base.status : "completed",
         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 +296,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 : "";
@@ -175,3 +321,60 @@ export function taskProgressText(msg) {
     }
     return description || lastTool;
 }
+function taskPatchStatus(value) {
+    switch (value) {
+        case "pending":
+            return "pending";
+        case "running":
+            return "in_progress";
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+        case "killed":
+            return "killed";
+        default:
+            return undefined;
+    }
+}
+function buildTaskMetadata(patch) {
+    const taskMetadata = {};
+    if (typeof patch.error === "string" && patch.error.length > 0) {
+        taskMetadata.error = patch.error;
+    }
+    if (typeof patch.is_backgrounded === "boolean") {
+        taskMetadata.is_backgrounded = patch.is_backgrounded;
+    }
+    if (typeof patch.end_time === "number" && Number.isFinite(patch.end_time) && patch.end_time >= 0) {
+        taskMetadata.end_time = Math.trunc(patch.end_time);
+    }
+    if (typeof patch.total_paused_ms === "number" &&
+        Number.isFinite(patch.total_paused_ms) &&
+        patch.total_paused_ms >= 0) {
+        taskMetadata.total_paused_ms = Math.trunc(patch.total_paused_ms);
+    }
+    return Object.keys(taskMetadata).length > 0 ? taskMetadata : undefined;
+}
+export function taskUpdatedFields(msg) {
+    const patch = msg.patch && typeof msg.patch === "object" ? msg.patch : {};
+    const fields = {};
+    const status = taskPatchStatus(patch.status);
+    const description = typeof patch.description === "string" ? patch.description : "";
+    const error = typeof patch.error === "string" ? patch.error : "";
+    if (status) {
+        fields.status = status;
+    }
+    if (description) {
+        fields.raw_output = description;
+        fields.content = [{ type: "content", content: { type: "text", text: description } }];
+    }
+    else if ((status === "failed" || status === "killed") && error) {
+        fields.raw_output = error;
+        fields.content = [{ type: "content", content: { type: "text", text: error } }];
+    }
+    const taskMetadata = buildTaskMetadata(patch);
+    if (taskMetadata) {
+        fields.task_metadata = taskMetadata;
+    }
+    return fields;
+}

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

@@ -110,7 +110,7 @@ function editDiffContent(name, input) {
     }
     return [];
 }
-export function createToolCall(toolUseId, name, input) {
+export function createToolCall(toolUseId, name, input, parentToolUseId = null) {
     return {
         tool_call_id: toolUseId,
         title: toolTitle(name, input),
@@ -122,6 +122,7 @@ export function createToolCall(toolUseId, name, input) {
         meta: {
             claudeCode: {
                 toolName: name,
+                parentToolUseId,
             },
         },
     };
@@ -134,18 +135,33 @@ function resultRecordCandidates(rawResult, rawContent) {
             candidates.push(record);
         }
     };
+    const pushRecords = (value) => {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                pushRecord(entry);
+            }
+            return;
+        }
+        pushRecord(value);
+    };
     const pushNestedRecords = (value) => {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                pushNestedRecords(entry);
+            }
+            return;
+        }
         const record = asRecordOrNull(value);
         if (!record) {
             return;
         }
-        pushRecord(record.result);
-        pushRecord(record.data);
-        pushRecord(record.content);
+        pushRecords(record.result);
+        pushRecords(record.data);
+        pushRecords(record.content);
     };
-    pushRecord(rawResult);
+    pushRecords(rawResult);
     pushNestedRecords(rawResult);
-    pushRecord(rawContent);
+    pushRecords(rawContent);
     pushNestedRecords(rawContent);
     return candidates;
 }
@@ -230,15 +246,9 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     if (toolName === "Bash") {
         for (const candidate of candidates) {
             const hasAssistantAutoBackgrounded = typeof candidate.assistantAutoBackgrounded === "boolean";
-            const hasTokenSaverOutput = typeof candidate.tokenSaverOutput === "string" && candidate.tokenSaverOutput.length > 0;
-            if (hasAssistantAutoBackgrounded || hasTokenSaverOutput) {
+            if (hasAssistantAutoBackgrounded) {
                 const bashMetadata = {};
-                if (hasAssistantAutoBackgrounded) {
-                    bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
-                }
-                if (hasTokenSaverOutput) {
-                    bashMetadata.token_saver_active = true;
-                }
+                bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
                 return {
                     bash: bashMetadata,
                 };
@@ -246,14 +256,6 @@ function extractToolOutputMetadata(toolName, rawResult, rawContent) {
         }
         return undefined;
     }
-    if (toolName === "ExitPlanMode") {
-        for (const candidate of candidates) {
-            if (typeof candidate.isUltraplan === "boolean") {
-                return { exit_plan_mode: { is_ultraplan: candidate.isUltraplan } };
-            }
-        }
-        return undefined;
-    }
     if (toolName === "TodoWrite") {
         for (const candidate of candidates) {
             if (typeof candidate.verificationNudgeNeeded === "boolean") {
@@ -476,8 +478,7 @@ function findBashResultRecord(rawResult, rawContent) {
         "stderr" in candidate ||
         "backgroundTaskId" in candidate ||
         "backgroundedByUser" in candidate ||
-        "assistantAutoBackgrounded" in candidate ||
-        "tokenSaverOutput" in candidate);
+        "assistantAutoBackgrounded" in candidate);
 }
 function bashBackgroundMessage(record) {
     const backgroundTaskId = typeof record.backgroundTaskId === "string" ? record.backgroundTaskId : "";
@@ -511,16 +512,48 @@ function buildBashDisplayOutput(record) {
     }
     return segments.join("\n");
 }
+function fileUnchangedResultText(rawResult, rawContent) {
+    for (const candidate of resultRecordCandidates(rawResult, rawContent)) {
+        if (candidate.type !== "file_unchanged") {
+            continue;
+        }
+        const file = asRecordOrNull(candidate.file);
+        const filePath = typeof file?.filePath === "string" ? file.filePath.trim() : "";
+        if (filePath) {
+            return `File unchanged: ${filePath}`;
+        }
+    }
+    return "";
+}
+function agentTitleFromAgentOutput(rawResult, rawContent) {
+    for (const candidate of resultRecordCandidates(rawResult, rawContent)) {
+        const agentType = typeof candidate.agentType === "string" ? candidate.agentType.trim() : "";
+        if (agentType) {
+            return agentType;
+        }
+    }
+    return "";
+}
 export function buildToolResultFields(isError, rawContent, base, rawResult) {
     const toolName = resolveToolName(base);
+    const fields = {
+        status: isError ? "failed" : "completed",
+    };
+    const fileUnchangedText = !isError && toolName === "Read" ? fileUnchangedResultText(rawResult, rawContent) : "";
+    if (fileUnchangedText) {
+        fields.raw_output = fileUnchangedText;
+        fields.content = [{ type: "content", content: { type: "text", text: fileUnchangedText } }];
+        return fields;
+    }
+    const agentTitle = !isError && toolName === "Agent" ? agentTitleFromAgentOutput(rawResult, rawContent) : "";
+    if (agentTitle) {
+        fields.title = agentTitle;
+    }
     const bashResultRecord = toolName === "Bash" ? findBashResultRecord(rawResult, rawContent) : undefined;
     const normalizedRawOutput = normalizeToolResultText(rawContent, isError);
     const rawOutput = bashResultRecord
         ? buildBashDisplayOutput(bashResultRecord)
         : normalizedRawOutput || JSON.stringify(rawContent);
-    const fields = {
-        status: isError ? "failed" : "completed",
-    };
     if (rawOutput) {
         fields.raw_output = rawOutput;
     }