claude-code-rust 0.6.0 → 0.7.1

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

@@ -0,0 +1,368 @@
+import { randomUUID } from "node:crypto";
+import { spawn as spawnChild } from "node:child_process";
+import fs from "node:fs";
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { AsyncQueue, logPermissionDebug } from "./shared.js";
+import { formatPermissionUpdates, permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
+import { writeEvent, failConnection, emitSessionUpdate, emitConnectEvent, } from "./events.js";
+import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.js";
+import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
+import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
+import { emitAuthRequired, emitFastModeUpdateIfChanged } from "./error_classification.js";
+export const sessions = new Map();
+const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
+const DEFAULT_MODEL_NAME = "default";
+const DEFAULT_PERMISSION_MODE = "default";
+export function sessionById(sessionId) {
+    return sessions.get(sessionId) ?? null;
+}
+export function updateSessionId(session, newSessionId) {
+    if (session.sessionId === newSessionId) {
+        return;
+    }
+    sessions.delete(session.sessionId);
+    session.sessionId = newSessionId;
+    sessions.set(newSessionId, session);
+}
+export async function closeSession(session) {
+    session.input.close();
+    session.query.close();
+    for (const pending of session.pendingPermissions.values()) {
+        pending.resolve?.({ behavior: "deny", message: "Session closed" });
+        pending.onOutcome?.({ outcome: "cancelled" });
+    }
+    session.pendingPermissions.clear();
+}
+export async function closeAllSessions() {
+    const active = Array.from(sessions.values());
+    sessions.clear();
+    await Promise.all(active.map((session) => closeSession(session)));
+}
+export async function createSession(params) {
+    const input = new AsyncQueue();
+    const provisionalSessionId = params.resume ?? randomUUID();
+    const initialModel = initialSessionModel(params.launchSettings);
+    const initialMode = initialSessionMode(params.launchSettings);
+    let session;
+    const canUseTool = async (toolName, inputData, options) => {
+        const toolUseId = options.toolUseID;
+        if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+            const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
+            return await requestExitPlanModeApproval(session, toolUseId, inputData, existing);
+        }
+        logPermissionDebug(`request tool_use_id=${toolUseId} tool=${toolName} blocked_path=${options.blockedPath ?? "<none>"} ` +
+            `decision_reason=${options.decisionReason ?? "<none>"} suggestions=${formatPermissionUpdates(options.suggestions)}`);
+        const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
+        if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
+            return await requestAskUserQuestionAnswers(session, toolUseId, toolName, inputData, existing);
+        }
+        const request = {
+            tool_call: existing,
+            options: permissionOptionsFromSuggestions(options.suggestions),
+        };
+        writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+        return await new Promise((resolve) => {
+            session.pendingPermissions.set(toolUseId, {
+                resolve,
+                toolName,
+                inputData: inputData,
+                suggestions: options.suggestions,
+            });
+        });
+    };
+    const claudeCodeExecutable = process.env.CLAUDE_CODE_EXECUTABLE;
+    const sdkDebugFile = process.env.CLAUDE_RS_SDK_DEBUG_FILE;
+    const enableSdkDebug = process.env.CLAUDE_RS_SDK_DEBUG === "1" || Boolean(sdkDebugFile);
+    const enableSpawnDebug = process.env.CLAUDE_RS_SDK_SPAWN_DEBUG === "1";
+    if (claudeCodeExecutable && !fs.existsSync(claudeCodeExecutable)) {
+        throw new Error(`CLAUDE_CODE_EXECUTABLE does not exist: ${claudeCodeExecutable}`);
+    }
+    let queryHandle;
+    try {
+        queryHandle = query({
+            prompt: input,
+            options: buildQueryOptions({
+                cwd: params.cwd,
+                resume: params.resume,
+                launchSettings: params.launchSettings,
+                provisionalSessionId,
+                input,
+                canUseTool,
+                claudeCodeExecutable,
+                sdkDebugFile,
+                enableSdkDebug,
+                enableSpawnDebug,
+                sessionIdForLogs: () => session.sessionId,
+            }),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`query() failed: node_executable=${process.execPath}; cwd=${params.cwd}; ` +
+            `resume=${params.resume ?? "<none>"}; ` +
+            `CLAUDE_CODE_EXECUTABLE=${claudeCodeExecutable ?? "<unset>"}; error=${message}`);
+    }
+    session = {
+        sessionId: provisionalSessionId,
+        cwd: params.cwd,
+        model: initialModel,
+        availableModels: [],
+        mode: initialMode,
+        fastModeState: "off",
+        query: queryHandle,
+        input,
+        connected: false,
+        connectEvent: params.connectEvent,
+        connectRequestId: params.requestId,
+        toolCalls: new Map(),
+        taskToolUseIds: new Map(),
+        pendingPermissions: new Map(),
+        authHintSent: false,
+        ...(params.resumeUpdates && params.resumeUpdates.length > 0
+            ? { resumeUpdates: params.resumeUpdates }
+            : {}),
+        ...(params.sessionsToCloseAfterConnect
+            ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
+            : {}),
+    };
+    sessions.set(provisionalSessionId, session);
+    // In stream-input mode the SDK may defer init until input arrives.
+    // Trigger initialization explicitly so the Rust UI can receive `connected`
+    // before the first user prompt.
+    void session.query
+        .initializationResult()
+        .then((result) => {
+        session.availableModels = mapAvailableModels(result.models);
+        if (!session.connected) {
+            emitConnectEvent(session);
+        }
+        // Proactively detect missing auth from account info so the UI can
+        // show the login hint immediately, without waiting for the first prompt.
+        const acct = result.account;
+        const hasCredentials = (typeof acct.email === "string" && acct.email.trim().length > 0) ||
+            (typeof acct.apiKeySource === "string" && acct.apiKeySource.trim().length > 0);
+        if (!hasCredentials) {
+            emitAuthRequired(session);
+        }
+        emitFastModeUpdateIfChanged(session, result.fast_mode_state);
+        const commands = Array.isArray(result.commands)
+            ? result.commands.map((command) => ({
+                name: command.name,
+                description: command.description ?? "",
+                input_hint: command.argumentHint ?? undefined,
+            }))
+            : [];
+        if (commands.length > 0) {
+            emitSessionUpdate(session.sessionId, { type: "available_commands_update", commands });
+        }
+        emitAvailableAgentsIfChanged(session, mapAvailableAgents(result.agents));
+        refreshAvailableAgents(session);
+    })
+        .catch((error) => {
+        if (session.connected) {
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
+        session.connectRequestId = undefined;
+    });
+    void (async () => {
+        try {
+            for await (const message of session.query) {
+                // Lazy import to break circular dependency at module-evaluation time.
+                const { handleSdkMessage } = await import("./message_handlers.js");
+                handleSdkMessage(session, message);
+            }
+            if (!session.connected) {
+                failConnection("agent stream ended before session initialization", params.requestId);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failConnection(`agent stream failed: ${message}`, params.requestId);
+        }
+    })();
+}
+function permissionModeFromLaunchSettings(rawMode) {
+    if (rawMode === undefined) {
+        return undefined;
+    }
+    switch (rawMode) {
+        case "default":
+        case "acceptEdits":
+        case "bypassPermissions":
+        case "plan":
+        case "dontAsk":
+            return rawMode;
+        default:
+            throw new Error(`unsupported launch_settings.permission_mode: ${rawMode}`);
+    }
+}
+function initialSessionModel(launchSettings) {
+    return launchSettings.model?.trim() || DEFAULT_MODEL_NAME;
+}
+function initialSessionMode(launchSettings) {
+    return permissionModeFromLaunchSettings(launchSettings.permission_mode) ?? DEFAULT_PERMISSION_MODE;
+}
+function thinkingConfigFromLaunchSettings(launchSettings) {
+    switch (launchSettings.thinking_mode) {
+        case undefined:
+            return undefined;
+        case "adaptive":
+            return { type: "adaptive" };
+        case "disabled":
+            return { type: "disabled" };
+        default:
+            throw new Error(`unsupported launch_settings.thinking_mode: ${String(launchSettings.thinking_mode)}`);
+    }
+}
+function effortFromLaunchSettings(launchSettings) {
+    if (launchSettings.thinking_mode !== "adaptive") {
+        return undefined;
+    }
+    return launchSettings.effort_level;
+}
+function systemPromptFromLaunchSettings(launchSettings) {
+    const language = launchSettings.language?.trim();
+    if (!language) {
+        return undefined;
+    }
+    return {
+        type: "preset",
+        preset: "claude_code",
+        append: `Always respond to the user in ${language} unless the user explicitly asks for a different language. ` +
+            `Keep code, shell commands, file paths, API names, tool names, and raw error text unchanged unless the user explicitly asks for translation.`,
+    };
+}
+export function buildQueryOptions(params) {
+    const permissionMode = permissionModeFromLaunchSettings(params.launchSettings.permission_mode);
+    const thinking = thinkingConfigFromLaunchSettings(params.launchSettings);
+    const effort = effortFromLaunchSettings(params.launchSettings);
+    const systemPrompt = systemPromptFromLaunchSettings(params.launchSettings);
+    return {
+        cwd: params.cwd,
+        includePartialMessages: true,
+        executable: "node",
+        ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
+        ...(params.launchSettings.model ? { model: params.launchSettings.model } : {}),
+        ...(systemPrompt ? { systemPrompt } : {}),
+        ...(permissionMode ? { permissionMode } : {}),
+        ...(thinking ? { thinking } : {}),
+        ...(effort ? { effort } : {}),
+        ...(params.claudeCodeExecutable
+            ? { pathToClaudeCodeExecutable: params.claudeCodeExecutable }
+            : {}),
+        ...(params.enableSdkDebug ? { debug: true } : {}),
+        ...(params.sdkDebugFile ? { debugFile: params.sdkDebugFile } : {}),
+        stderr: (line) => {
+            if (line.trim().length > 0) {
+                console.error(`[sdk stderr] ${line}`);
+            }
+        },
+        ...(params.enableSpawnDebug
+            ? {
+                spawnClaudeCodeProcess: (options) => {
+                    console.error(`[sdk spawn] command=${options.command} args=${JSON.stringify(options.args)} cwd=${options.cwd ?? "<none>"}`);
+                    const child = spawnChild(options.command, options.args, {
+                        cwd: options.cwd,
+                        env: options.env,
+                        signal: options.signal,
+                        stdio: ["pipe", "pipe", "pipe"],
+                        windowsHide: true,
+                    });
+                    child.on("error", (error) => {
+                        console.error(`[sdk spawn error] code=${error.code ?? "<none>"} message=${error.message}`);
+                    });
+                    return child;
+                },
+            }
+            : {}),
+        // Match claude-agent-acp defaults to avoid emitting an empty
+        // --setting-sources argument.
+        settingSources: DEFAULT_SETTING_SOURCES,
+        resume: params.resume,
+        canUseTool: params.canUseTool,
+        onElicitation: async (request) => {
+            const requestMode = typeof request.mode === "string" ? request.mode : "unknown";
+            const requestServer = typeof request.serverName === "string" && request.serverName.trim().length > 0
+                ? request.serverName
+                : "unknown";
+            const requestMessage = typeof request.message === "string" && request.message.trim().length > 0
+                ? request.message
+                : "<no message>";
+            console.error(`[sdk warn] elicitation unsupported without MCP settings UI; ` +
+                `auto-canceling session_id=${params.sessionIdForLogs()} server=${requestServer} ` +
+                `mode=${requestMode} message=${JSON.stringify(requestMessage)}`);
+            return { action: "cancel" };
+        },
+    };
+}
+function mapAvailableModels(models) {
+    if (!Array.isArray(models)) {
+        return [];
+    }
+    return models
+        .filter((entry) => {
+        return (typeof entry?.value === "string" &&
+            entry.value.trim().length > 0 &&
+            typeof entry.displayName === "string" &&
+            entry.displayName.trim().length > 0);
+    })
+        .map((entry) => ({
+        id: entry.value,
+        display_name: entry.displayName,
+        supports_effort: entry.supportsEffort === true,
+        supported_effort_levels: Array.isArray(entry.supportedEffortLevels)
+            ? entry.supportedEffortLevels.filter((level) => level === "low" || level === "medium" || level === "high")
+            : [],
+        ...(typeof entry.description === "string" && entry.description.trim().length > 0
+            ? { description: entry.description }
+            : {}),
+    }));
+}
+export function handlePermissionResponse(command) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        logPermissionDebug(`response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        return;
+    }
+    const resolver = session.pendingPermissions.get(command.tool_call_id);
+    if (!resolver) {
+        logPermissionDebug(`response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        return;
+    }
+    session.pendingPermissions.delete(command.tool_call_id);
+    const outcome = command.outcome;
+    if (resolver.onOutcome) {
+        resolver.onOutcome(outcome);
+        return;
+    }
+    if (!resolver.resolve) {
+        logPermissionDebug(`response dropped: resolver missing callback session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        return;
+    }
+    const selectedOption = outcome.outcome === "selected" ? outcome.option_id : "cancelled";
+    logPermissionDebug(`response session_id=${command.session_id} tool_call_id=${command.tool_call_id} tool=${resolver.toolName} ` +
+        `selected=${selectedOption} suggestions=${formatPermissionUpdates(resolver.suggestions)}`);
+    if (outcome.outcome === "selected" &&
+        (outcome.option_id === "allow_once" ||
+            outcome.option_id === "allow_session" ||
+            outcome.option_id === "allow_always")) {
+        setToolCallStatus(session, command.tool_call_id, "in_progress");
+    }
+    else if (outcome.outcome === "selected") {
+        setToolCallStatus(session, command.tool_call_id, "failed", "Permission denied");
+    }
+    else {
+        setToolCallStatus(session, command.tool_call_id, "failed", "Permission cancelled");
+    }
+    const permissionResult = permissionResultFromOutcome(outcome, command.tool_call_id, resolver.inputData, resolver.suggestions, resolver.toolName);
+    if (permissionResult.behavior === "allow") {
+        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=allow updated_permissions=` +
+            `${formatPermissionUpdates(permissionResult.updatedPermissions)}`);
+    }
+    else {
+        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=deny message=${permissionResult.message}`);
+    }
+    resolver.resolve(permissionResult);
+}

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

@@ -4,3 +4,52 @@ export function asRecordOrNull(value) {
     }
     return value;
 }
+export class AsyncQueue {
+    items = [];
+    waiters = [];
+    closed = false;
+    enqueue(item) {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value: item, done: false });
+            return;
+        }
+        this.items.push(item);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter?.({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                if (this.items.length > 0) {
+                    const value = this.items.shift();
+                    return { value: value, done: false };
+                }
+                if (this.closed) {
+                    return { value: undefined, done: true };
+                }
+                return await new Promise((resolve) => {
+                    this.waiters.push(resolve);
+                });
+            },
+        };
+    }
+}
+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

@@ -0,0 +1,66 @@
+import { asRecordOrNull } from "./shared.js";
+export function numberField(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function parseFastModeState(value) {
+    if (value === "off" || value === "cooldown" || value === "on") {
+        return value;
+    }
+    return null;
+}
+export function parseRateLimitStatus(value) {
+    if (value === "allowed" || value === "allowed_warning" || value === "rejected") {
+        return value;
+    }
+    return null;
+}
+export function buildRateLimitUpdate(rateLimitInfo) {
+    const info = asRecordOrNull(rateLimitInfo);
+    if (!info) {
+        return null;
+    }
+    const status = parseRateLimitStatus(info.status);
+    if (!status) {
+        return null;
+    }
+    const update = {
+        type: "rate_limit_update",
+        status,
+    };
+    const resetsAt = numberField(info, "resetsAt");
+    if (resetsAt !== undefined) {
+        update.resets_at = resetsAt;
+    }
+    const utilization = numberField(info, "utilization");
+    if (utilization !== undefined) {
+        update.utilization = utilization;
+    }
+    if (typeof info.rateLimitType === "string" && info.rateLimitType.length > 0) {
+        update.rate_limit_type = info.rateLimitType;
+    }
+    const overageStatus = parseRateLimitStatus(info.overageStatus);
+    if (overageStatus) {
+        update.overage_status = overageStatus;
+    }
+    const overageResetsAt = numberField(info, "overageResetsAt");
+    if (overageResetsAt !== undefined) {
+        update.overage_resets_at = overageResetsAt;
+    }
+    if (typeof info.overageDisabledReason === "string" && info.overageDisabledReason.length > 0) {
+        update.overage_disabled_reason = info.overageDisabledReason;
+    }
+    if (typeof info.isUsingOverage === "boolean") {
+        update.is_using_overage = info.isUsingOverage;
+    }
+    const surpassedThreshold = numberField(info, "surpassedThreshold");
+    if (surpassedThreshold !== undefined) {
+        update.surpassed_threshold = surpassedThreshold;
+    }
+    return update;
+}

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

@@ -0,0 +1,168 @@
+import { emitSessionUpdate } from "./events.js";
+import { buildToolResultFields, createToolCall } from "./tooling.js";
+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 });
+        return;
+    }
+    const fields = {
+        title: toolCall.title,
+        kind: toolCall.kind,
+        status,
+        raw_input: toolCall.raw_input,
+        locations: toolCall.locations,
+        meta: toolCall.meta,
+    };
+    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;
+    }
+}
+export function ensureToolCallVisible(session, toolUseId, toolName, input) {
+    const existing = session.toolCalls.get(toolUseId);
+    if (existing) {
+        return existing;
+    }
+    const toolCall = createToolCall(toolUseId, toolName, input);
+    session.toolCalls.set(toolUseId, toolCall);
+    emitSessionUpdate(session.sessionId, { type: "tool_call", tool_call: 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;
+        }
+        const todoObj = todo;
+        const content = typeof todoObj.content === "string" ? todoObj.content : "";
+        const status = typeof todoObj.status === "string" ? todoObj.status : "pending";
+        if (!content) {
+            return null;
+        }
+        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) {
+    const base = session.toolCalls.get(toolUseId);
+    const fields = buildToolResultFields(isError, rawContent, base);
+    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;
+        }
+    }
+}
+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;
+    }
+}
+export function emitToolProgressUpdate(session, toolUseId, toolName) {
+    const existing = session.toolCalls.get(toolUseId);
+    if (!existing) {
+        emitToolCall(session, toolUseId, toolName, {});
+        return;
+    }
+    if (existing.status === "in_progress") {
+        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";
+}
+export function emitToolSummaryUpdate(session, toolUseId, summary) {
+    const base = session.toolCalls.get(toolUseId);
+    if (!base) {
+        return;
+    }
+    const fields = {
+        status: base.status === "failed" ? "failed" : "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;
+}
+export function setToolCallStatus(session, toolUseId, status, message) {
+    const base = session.toolCalls.get(toolUseId);
+    if (!base) {
+        return;
+    }
+    const fields = { status };
+    if (message && message.length > 0) {
+        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;
+    }
+}
+export function resolveTaskToolUseId(session, msg) {
+    const direct = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
+    if (direct) {
+        return direct;
+    }
+    const taskId = typeof msg.task_id === "string" ? msg.task_id : "";
+    if (!taskId) {
+        return "";
+    }
+    return session.taskToolUseIds.get(taskId) ?? "";
+}
+export function taskProgressText(msg) {
+    const description = typeof msg.description === "string" ? msg.description : "";
+    const lastTool = typeof msg.last_tool_name === "string" ? msg.last_tool_name : "";
+    if (description && lastTool) {
+        return `${description} (last tool: ${lastTool})`;
+    }
+    return description || lastTool;
+}