claude-code-rust 0.14.2 → 0.14.3

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

@@ -8,7 +8,7 @@ import { linkTaskToolUse, unlinkTaskToolUse } from "./task_links.js";
 import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdate, emitFastModeUpdateIfChanged, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableAgentsFromNames, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { mapInitSlashCommands, mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
-import { buildApiRetryUpdate, buildRateLimitUpdate, buildSubagentRetryUpdate, normalizeSettingsParseErrors, numberField, parseApiRetryError, parseRuntimeSessionState, } from "./state_parsing.js";
+import { buildApiRetryUpdate, buildRateLimitUpdate, buildSubagentRetryUpdate, normalizeSettingsParseErrors, nonNegativeIntegerField, numberField, parseApiRetryError, parseRuntimeSessionState, } from "./state_parsing.js";
 import { looksLikeAuthRequired } from "./auth.js";
 import { emitCurrentModelUpdate, refreshCurrentModel, updateSessionId } from "./session_lifecycle.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
@@ -576,6 +576,18 @@ function logContentBlockLinkage(session, blockType, toolUseId, toolName, linkage
         },
     });
 }
+function resolveToolProgressTarget(session, taskToolUseId, toolUseId, parentToolUseId) {
+    if (taskToolUseId && session.toolCalls.has(taskToolUseId)) {
+        return { toolUseId: taskToolUseId, source: "task" };
+    }
+    if (toolUseId && session.toolCalls.has(toolUseId)) {
+        return { toolUseId, source: "tool" };
+    }
+    if (parentToolUseId && session.toolCalls.has(parentToolUseId)) {
+        return { toolUseId: parentToolUseId, source: "parent" };
+    }
+    return null;
+}
 function hideToolUse(session, toolUseId) {
     if (toolUseId) {
         session.hiddenToolUseIds.add(toolUseId);
@@ -1036,12 +1048,31 @@ export function handleSdkMessage(session, message) {
                 emitSessionUpdate(session.sessionId, { type: "current_mode_update", current_mode_id: mode });
             }
             if (msg.status === "compacting") {
-                emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "compacting" });
+                emitSessionUpdate(session.sessionId, { type: "compaction_update", phase: "started" });
             }
             else if (msg.status === "requesting") {
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "requesting" });
             }
             else if (msg.status === null) {
+                if (msg.compact_result === "success") {
+                    emitSessionUpdate(session.sessionId, {
+                        type: "compaction_update",
+                        phase: "finished",
+                        result: "success",
+                    });
+                }
+                else if (msg.compact_result === "failed") {
+                    const compactError = typeof msg.compact_error === "string" && msg.compact_error.trim().length > 0
+                        ? msg.compact_error.trim()
+                        : undefined;
+                    emitSessionUpdate(session.sessionId, {
+                        type: "compaction_update",
+                        phase: "finished",
+                        result: "failed",
+                        error_code: compactError === "too_few_groups" ? "too_few_groups" : "unknown",
+                        ...(compactError ? { error: compactError } : {}),
+                    });
+                }
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "idle" });
             }
             emitFastModeUpdateIfChanged(session, msg.fast_mode_state, msg.fast_mode_disabled_reason);
@@ -1053,12 +1084,17 @@ export function handleSdkMessage(session, message) {
                 return;
             }
             const trigger = compactMetadata.trigger;
-            const preTokens = numberField(compactMetadata, "pre_tokens", "preTokens");
+            const preTokens = nonNegativeIntegerField(compactMetadata, "pre_tokens", "preTokens");
+            const postTokens = nonNegativeIntegerField(compactMetadata, "post_tokens", "postTokens");
+            const durationMs = nonNegativeIntegerField(compactMetadata, "duration_ms", "durationMs");
             if ((trigger === "manual" || trigger === "auto") && preTokens !== undefined) {
                 emitSessionUpdate(session.sessionId, {
-                    type: "compaction_boundary",
+                    type: "compaction_update",
+                    phase: "boundary",
                     trigger,
                     pre_tokens: preTokens,
+                    ...(postTokens !== undefined ? { post_tokens: postTokens } : {}),
+                    ...(durationMs !== undefined ? { duration_ms: durationMs } : {}),
                 });
             }
             return;
@@ -1141,25 +1177,29 @@ export function handleSdkMessage(session, message) {
     if (type === "tool_progress") {
         const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
         const toolName = typeof msg.tool_name === "string" ? msg.tool_name : "Tool";
+        const parentToolUseId = typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : "";
         const taskId = typeof msg.task_id === "string" ? msg.task_id : "";
         const taskToolUseId = taskId ? session.taskToolUseIds.get(taskId) ?? "" : "";
-        const resolvedToolUseId = taskToolUseId || toolUseId;
-        if (isHiddenToolUse(session, resolvedToolUseId, toolName)) {
+        if (isHiddenToolUse(session, toolUseId, toolName)) {
             return;
         }
+        const progressTarget = resolveToolProgressTarget(session, taskToolUseId, toolUseId, parentToolUseId);
+        const resolvedToolUseId = progressTarget?.toolUseId ?? "";
         bridgeLogger.debug({
             target: LOG_TARGETS.APP_TOOL,
             eventName: "sdk_tool_progress_linkage_observed",
             message: "SDK tool progress linkage observed",
-            outcome: typeof msg.parent_tool_use_id === "string" ? "child" : "root_or_unknown",
+            outcome: progressTarget?.source ?? "orphaned",
             sessionId: session.sessionId,
-            toolCallId: resolvedToolUseId || undefined,
+            toolCallId: resolvedToolUseId || toolUseId || undefined,
             fields: {
                 tool_name: toolName,
                 tool_use_id: toolUseId || undefined,
-                parent_tool_use_id: typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : undefined,
+                parent_tool_use_id: parentToolUseId || undefined,
                 task_id: taskId || undefined,
                 task_resolved_tool_use_id: taskToolUseId || undefined,
+                resolved_tool_use_id: resolvedToolUseId || undefined,
+                correlation_source: progressTarget?.source,
             },
         });
         if (resolvedToolUseId) {
@@ -1178,7 +1218,7 @@ export function handleSdkMessage(session, message) {
             const subagentType = typeof msg.subagent_type === "string" && msg.subagent_type.trim()
                 ? msg.subagent_type.trim()
                 : undefined;
-            emitToolProgressUpdate(session, resolvedToolUseId, toolName, {
+            emitToolProgressUpdate(session, resolvedToolUseId, {
                 ...(subagentRetry
                     ? { subagentRetry }
                     : hasSubagentRetry

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

@@ -15,7 +15,7 @@ function nonNegativeNumberField(record, ...keys) {
     }
     return value;
 }
-function nonNegativeIntegerField(record, ...keys) {
+export function nonNegativeIntegerField(record, ...keys) {
     const value = numberField(record, ...keys);
     return value !== undefined && value >= 0 && Number.isInteger(value) ? value : undefined;
 }

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

@@ -339,14 +339,15 @@ export function finalizeOpenToolCalls(session, status) {
         emitToolCallUpdate(session, toolUseId, { status }, "finalize");
     }
 }
-export function emitToolProgressUpdate(session, toolUseId, toolName, progress = {}) {
-    let existing = session.toolCalls.get(toolUseId);
+/**
+ * Apply advisory progress only to a tool created by an authoritative tool-use event.
+ */
+export function emitToolProgressUpdate(session, toolUseId, progress = {}) {
+    const existing = session.toolCalls.get(toolUseId);
     if (!existing) {
-        emitToolCall(session, toolUseId, toolName, {});
-        existing = session.toolCalls.get(toolUseId);
+        return;
     }
-    if (!existing ||
-        existing.status === "completed" ||
+    if (existing.status === "completed" ||
         existing.status === "failed" ||
         existing.status === "killed") {
         return;

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

@@ -23,6 +23,19 @@ const WORKFLOW_TOOL_NAME = "Workflow";
 const PROJECTS_TOOL_NAME = "Projects";
 const ARTIFACT_TOOL_NAME = "Artifact";
 const SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME = "ShowOnboardingRolePicker";
+const SKILL_TOOL_NAME = "Skill";
+const SKILL_WORD_OVERRIDES = {
+    api: "API",
+    ci: "CI",
+    cli: "CLI",
+    gh: "GH",
+    github: "GitHub",
+    mcp: "MCP",
+    pdf: "PDF",
+    sdk: "SDK",
+    ui: "UI",
+    ux: "UX",
+};
 const READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResource";
 const READ_MCP_RESOURCE_DIR_TOOL_NAME = "ReadMcpResourceDir";
 const SEARCH_OUTPUT_MODES = new Set(["content", "files_with_matches", "count"]);
@@ -183,6 +196,7 @@ export function normalizeToolKind(name) {
         case "Projects":
         case "Artifact":
         case "ShowOnboardingRolePicker":
+        case SKILL_TOOL_NAME:
             return "other";
         case "Task":
         case "Agent":
@@ -194,6 +208,34 @@ export function normalizeToolKind(name) {
             return "think";
     }
 }
+function skillDisplayName(rawName) {
+    const trimmed = rawName.trim();
+    const segments = trimmed.split(":");
+    if (segments.length > 2 ||
+        segments.some((segment) => !segment || !/^[a-zA-Z0-9]+(?:[-_][a-zA-Z0-9]+)*$/.test(segment))) {
+        return trimmed;
+    }
+    const displaySegments = segments.map((segment) => segment
+        .split(/[-_]/)
+        .map((word) => skillDisplayWord(word))
+        .join(" "));
+    if (displaySegments.length === 2 &&
+        displaySegments[0].toLowerCase() === displaySegments[1].toLowerCase()) {
+        return displaySegments[1];
+    }
+    return displaySegments.join(" / ");
+}
+function skillDisplayWord(word) {
+    const override = SKILL_WORD_OVERRIDES[word.toLowerCase()];
+    if (override) {
+        return override;
+    }
+    if (/^[A-Z0-9]+$/.test(word) ||
+        (/[a-z]/.test(word) && /[A-Z]/.test(word) && !/^[A-Z][a-z0-9]*$/.test(word))) {
+        return word;
+    }
+    return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
+}
 export function toolTitle(name, input, context = {}) {
     const agentTitle = agentInputTitle(name, input);
     if (agentTitle) {
@@ -263,6 +305,12 @@ export function toolTitle(name, input, context = {}) {
     if (name === SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME) {
         return SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME;
     }
+    if (name === SKILL_TOOL_NAME) {
+        const skillName = nonEmptyString(input.skill);
+        return skillName
+            ? `${SKILL_TOOL_NAME}: ${skillDisplayName(skillName)}`
+            : SKILL_TOOL_NAME;
+    }
     if (name === "EnterWorktree") {
         const worktreeName = typeof input.name === "string" ? input.name.trim() : "";
         return worktreeName || "EnterWorktree";
@@ -369,6 +417,17 @@ function resultRecordCandidates(rawResult, rawContent) {
     pushNestedRecords(rawContent);
     return candidates;
 }
+function imageReadResultText(rawResult, rawContent, rawInput) {
+    const isImage = resultRecordCandidates(rawResult, rawContent).some((candidate) => candidate.type === "image");
+    if (!isImage) {
+        return undefined;
+    }
+    const input = asRecordOrNull(rawInput);
+    const filePath = typeof input?.file_path === "string" ? input.file_path.trim() : "";
+    const normalizedPath = filePath.replaceAll("\\", "/");
+    const fileName = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
+    return fileName ? `Viewed Image ${fileName}` : "Viewed Image";
+}
 function parseJsonCandidate(value) {
     const text = typeof value === "string" ? value : extractText(value);
     const trimmed = text.trim();
@@ -1593,6 +1652,51 @@ function collectResultCandidates(rawResult, rawContent) {
     }
     return candidates;
 }
+function parseSkillResult(toolName, rawResult, rawContent) {
+    if (toolName !== SKILL_TOOL_NAME) {
+        return undefined;
+    }
+    for (const candidate of collectResultCandidates(rawResult, rawContent)) {
+        const commandName = nonEmptyString(candidate.commandName);
+        if (!commandName || typeof candidate.success !== "boolean") {
+            continue;
+        }
+        if (candidate.status === "forked") {
+            const agentId = nonEmptyString(candidate.agentId);
+            if (!agentId || typeof candidate.result !== "string") {
+                continue;
+            }
+            if (candidate.background !== undefined && typeof candidate.background !== "boolean") {
+                continue;
+            }
+            return {
+                success: candidate.success,
+                commandName,
+                status: "forked",
+                agentId,
+                result: candidate.result,
+                ...(typeof candidate.background === "boolean"
+                    ? { background: candidate.background }
+                    : {}),
+            };
+        }
+        if (candidate.status === undefined || candidate.status === "inline") {
+            const allowedToolsValid = candidate.allowedTools === undefined ||
+                (Array.isArray(candidate.allowedTools) &&
+                    candidate.allowedTools.every((tool) => typeof tool === "string"));
+            const modelValid = candidate.model === undefined || typeof candidate.model === "string";
+            if (!allowedToolsValid || !modelValid) {
+                continue;
+            }
+            return {
+                success: candidate.success,
+                commandName,
+                status: "inline",
+            };
+        }
+    }
+    return undefined;
+}
 function monitorResultFields(toolName, rawResult, rawContent) {
     if (toolName !== MONITOR_TOOL_NAME) {
         return undefined;
@@ -1797,6 +1901,32 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
     if (outputMetadata) {
         fields.output_metadata = outputMetadata;
     }
+    const skillResult = !isError ? parseSkillResult(toolName, rawResult, rawContent) : undefined;
+    if (skillResult) {
+        fields.title = `${SKILL_TOOL_NAME}: ${skillDisplayName(skillResult.commandName)}`;
+        if (!skillResult.success) {
+            fields.status = "failed";
+        }
+        else if (skillResult.status === "inline") {
+            return fields;
+        }
+        else {
+            const output = skillResult.result.trim();
+            if (output) {
+                fields.raw_output = output;
+                fields.content = [{ type: "content", content: { type: "text", text: output } }];
+            }
+            return fields;
+        }
+    }
+    const imageReadText = !isError && toolName === "Read"
+        ? imageReadResultText(rawResult, rawContent, base?.raw_input)
+        : undefined;
+    if (imageReadText !== undefined) {
+        fields.raw_output = imageReadText;
+        fields.content = [{ type: "content", content: { type: "text", text: imageReadText } }];
+        return fields;
+    }
     const fileUnchangedText = !isError && toolName === "Read" ? fileUnchangedResultText(rawResult, rawContent) : "";
     if (fileUnchangedText) {
         fields.raw_output = fileUnchangedText;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-rust",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "Claude Code Rust - native Rust terminal interface for Claude Code",
   "keywords": [
     "cli",
@@ -36,12 +36,12 @@
     "@anthropic-ai/claude-agent-sdk": "0.3.220"
   },
   "optionalDependencies": {
-    "@srothgan/claude-code-rust-darwin-arm64": "0.14.2",
-    "@srothgan/claude-code-rust-darwin-x64": "0.14.2",
-    "@srothgan/claude-code-rust-linux-x64-gnu": "0.14.2",
-    "@srothgan/claude-code-rust-linux-arm64-gnu": "0.14.2",
-    "@srothgan/claude-code-rust-win32-x64-msvc": "0.14.2",
-    "@srothgan/claude-code-rust-win32-arm64-msvc": "0.14.2"
+    "@srothgan/claude-code-rust-darwin-arm64": "0.14.3",
+    "@srothgan/claude-code-rust-darwin-x64": "0.14.3",
+    "@srothgan/claude-code-rust-linux-x64-gnu": "0.14.3",
+    "@srothgan/claude-code-rust-linux-arm64-gnu": "0.14.3",
+    "@srothgan/claude-code-rust-win32-x64-msvc": "0.14.3",
+    "@srothgan/claude-code-rust-win32-arm64-msvc": "0.14.3"
   },
   "engines": {
     "node": ">=24"