claude-code-rust 0.12.1 → 0.12.3

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

@@ -1,8 +1,11 @@
 import { emitSessionUpdate } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
-import { buildToolResultFields, createToolCall } from "./tooling.js";
+import { asRecordOrNull } from "./shared.js";
+import { applyTaskToolResult } from "./tasks.js";
+import { activeTaskIdForToolUse, linkTaskToolUse, unlinkTaskToolUse } from "./task_links.js";
+import { backgroundToolLaunchTaskIdFromResult, buildToolResultFields, createToolCall, } from "./tooling.js";
 const TOOL_SUMMARY_TOOL_NAMES = new Set(["Agent", "Task", "WebSearch", "WebFetch", "ExitPlanMode"]);
-const TASK_LIFECYCLE_TOOL_NAMES = new Set(["Agent", "Task"]);
+const TASK_LIFECYCLE_TOOL_NAMES = new Set(["Agent", "Task", "Monitor", "Workflow"]);
 function jsonSize(value) {
     if (value === undefined) {
         return undefined;
@@ -40,6 +43,10 @@ export function toolAcceptsTaskLifecycle(base) {
     const baseToolName = toolName(base);
     return Boolean(baseToolName && TASK_LIFECYCLE_TOOL_NAMES.has(baseToolName));
 }
+export function defersTaskNotificationCompletion(base) {
+    const baseToolName = toolName(base);
+    return baseToolName === "Agent" || baseToolName === "Task";
+}
 function classifyFailureKind(rawOutput) {
     if (!rawOutput) {
         return "failed";
@@ -81,6 +88,26 @@ function parentToolUseIdFromMeta(meta) {
         : null;
     return parentToolUseId;
 }
+function applyToolCorrelationMetadata(toolCall, metadata) {
+    if (!metadata?.requestId && !metadata?.subagentType && !metadata?.taskDescription) {
+        return;
+    }
+    const meta = toolCall.meta && typeof toolCall.meta === "object" && !Array.isArray(toolCall.meta)
+        ? toolCall.meta
+        : {};
+    const claudeCode = meta.claudeCode && typeof meta.claudeCode === "object" && !Array.isArray(meta.claudeCode)
+        ? meta.claudeCode
+        : {};
+    toolCall.meta = {
+        ...meta,
+        claudeCode: {
+            ...claudeCode,
+            ...(metadata.requestId ? { requestId: metadata.requestId } : {}),
+            ...(metadata.subagentType ? { subagentType: metadata.subagentType } : {}),
+            ...(metadata.taskDescription ? { taskDescription: metadata.taskDescription } : {}),
+        },
+    };
+}
 function mergeTaskMetadata(current, update) {
     if (update === undefined) {
         return current;
@@ -188,21 +215,52 @@ function emitInitialToolCall(session, toolCall, updateKind = "initial") {
     logToolCallSubmitted(session.sessionId, toolCall, updateKind);
     emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: toolCall });
 }
-export function emitToolCallUpdate(session, toolUseId, fields, updateKind) {
+function taskTitleContext(session, name, input) {
+    const taskId = name === "TaskUpdate"
+        ? typeof input.taskId === "string"
+            ? input.taskId
+            : ""
+        : name === "TaskOutput" || name === "TaskStop"
+            ? typeof input.task_id === "string"
+                ? input.task_id
+                : typeof input.shell_id === "string"
+                    ? input.shell_id
+                    : ""
+            : "";
+    if (!taskId) {
+        return {};
+    }
+    const task = session.tasksById.get(taskId);
+    return {
+        ...(task?.subject ? { taskSubject: task.subject } : {}),
+    };
+}
+export function emitToolCallUpdate(session, toolUseId, fields, updateKind, sourceMessageUuid) {
     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 },
+        tool_call_update: {
+            tool_call_id: toolUseId,
+            ...(sourceMessageUuid ? { source_message_uuid: sourceMessageUuid } : {}),
+            fields,
+        },
     });
     if (base) {
+        if (sourceMessageUuid) {
+            base.source_message_uuid = sourceMessageUuid;
+        }
         applyFieldsToBase(base, fields);
     }
 }
-export function emitToolCall(session, toolUseId, name, input, parentToolUseId = null) {
+export function emitToolCall(session, toolUseId, name, input, parentToolUseId = null, metadata, sourceMessageUuid) {
     const existing = session.toolCalls.get(toolUseId);
     const resolvedParentToolUseId = parentToolUseId ?? parentToolUseIdFromMeta(existing?.meta);
-    const toolCall = createToolCall(toolUseId, name, input, resolvedParentToolUseId);
+    const toolCall = createToolCall(toolUseId, name, input, resolvedParentToolUseId, taskTitleContext(session, name, input));
+    applyToolCorrelationMetadata(toolCall, metadata);
+    if (sourceMessageUuid) {
+        toolCall.source_message_uuid = sourceMessageUuid;
+    }
     const status = "in_progress";
     toolCall.status = status;
     if (!existing) {
@@ -220,53 +278,49 @@ export function emitToolCall(session, toolUseId, name, input, parentToolUseId =
     if (toolCall.content.length > 0) {
         fields.content = toolCall.content;
     }
-    emitToolCallUpdate(session, toolUseId, fields, "refresh");
+    emitToolCallUpdate(session, toolUseId, fields, "refresh", sourceMessageUuid);
 }
 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);
+            const refreshed = createToolCall(toolUseId, toolName, input, parentToolUseId, taskTitleContext(session, toolName, input));
             emitToolCallUpdate(session, toolUseId, { meta: refreshed.meta }, "refresh");
         }
         return existing;
     }
-    const toolCall = createToolCall(toolUseId, toolName, input, parentToolUseId);
+    const toolCall = createToolCall(toolUseId, toolName, input, parentToolUseId, taskTitleContext(session, toolName, input));
     emitInitialToolCall(session, toolCall);
     return toolCall;
 }
-export function emitPlanIfTodoWrite(session, name, input) {
-    if (name !== "TodoWrite" || !Array.isArray(input.todos)) {
-        return;
-    }
-    const entries = input.todos
-        .map((todo) => {
-        if (!todo || typeof todo !== "object") {
-            return null;
+export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent, sourceMessageUuid) {
+    const base = session.toolCalls.get(toolUseId);
+    const baseToolName = toolNameFromMeta(base?.meta) ?? "";
+    const fields = buildToolResultFields(isError, rawContent, base, rawResult, taskTitleContext(session, baseToolName, asRecordOrNull(base?.raw_input) ?? {}));
+    if (!isError) {
+        const taskId = backgroundToolLaunchTaskIdFromResult(baseToolName, rawResult, rawContent);
+        if (taskId) {
+            linkTaskToolUse(session, taskId, toolUseId);
         }
-        const todoObj = todo;
-        const content = typeof todoObj.content === "string" ? todoObj.content : "";
-        const status = typeof todoObj.status === "string" ? todoObj.status : "pending";
-        if (!content) {
-            return null;
+    }
+    emitToolCallUpdate(session, toolUseId, fields, "result", sourceMessageUuid);
+    applyTaskToolResult(session, toolUseId, isError, rawContent, rawResult);
+    if (baseToolName === "Agent" || baseToolName === "Task") {
+        const taskId = activeTaskIdForToolUse(session, toolUseId);
+        if (taskId) {
+            unlinkTaskToolUse(session, taskId);
         }
-        return { content, status, active_form: status };
-    })
-        .filter((entry) => entry !== null);
-    if (entries.length > 0) {
-        emitSessionUpdate(session.sessionId, { type: "plan", entries });
     }
 }
-export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent) {
-    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;
         }
+        if (toolAcceptsTaskLifecycle(toolCall) && activeTaskIdForToolUse(session, toolUseId)) {
+            continue;
+        }
         emitToolCallUpdate(session, toolUseId, { status }, "finalize");
     }
 }
@@ -366,6 +420,9 @@ function buildTaskMetadata(patch) {
         patch.total_paused_ms >= 0) {
         taskMetadata.total_paused_ms = Math.trunc(patch.total_paused_ms);
     }
+    if (typeof patch.status === "string" && ["completed", "failed", "killed"].includes(patch.status)) {
+        taskMetadata.terminal_status = patch.status;
+    }
     return Object.keys(taskMetadata).length > 0 ? taskMetadata : undefined;
 }
 export function taskUpdatedFields(msg) {