@astrosheep/keiyaku 1.0.1 → 1.0.2

package/build/agents/providers/claude-agent-sdk.js

@@ -1,9 +1,35 @@
 import { z } from "zod";
 import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../session.js";
-import { coerceString } from "../index.js";
 import { createProjectionDriver } from "../harness/execution-handle.js";
-import { buildSubagentEnv, createAbortError, emitProviderEvidence, linkAbortSignal, sha256Utf8 } from "../harness/runtime.js";
+import { activityCallFromNamedTool, boundActivityExcerpt } from "../harness/activity-values.js";
+import { buildSubagentEnv, coerceString, createAbortError, emitProviderEvidence, linkAbortSignal, sha256Utf8 } from "../harness/runtime.js";
+import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../harness/events.js";
+const CLAUDE_MAPPED = new Set(["assistant", "user", "result", "system", "fallback"]);
+const CLAUDE_ACKNOWLEDGED_UNPERSISTED = new Set([
+    "stream_event",
+    "rate_limit_event",
+    "control_cancel_request",
+    "control_request",
+    "control_response",
+    "conversation_reset",
+    "keep_alive",
+    "local",
+    "prompt_suggestion",
+    "tool_progress",
+    "tool_use_summary",
+    "auth_status",
+]);
+function claudeIngressDisposition(type) {
+    if (CLAUDE_MAPPED.has(type))
+        return "mapped";
+    if (CLAUDE_ACKNOWLEDGED_UNPERSISTED.has(type))
+        return "acknowledged-unpersisted";
+    return "unknown";
+}
+function toClaudeSdkEffort(effort) {
+    return effort; // opacity boundary
+}
 export const claudeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });
 const CLAUDE_AGENT_SDK_PROVIDER = "claude-agent-sdk";
 let claudeAgentSdkLoader;
@@ -31,6 +57,119 @@ function extractAssistantMessage(event) {
 function extractAssistantMessageModel(event) {
     return coerceString(event.message.model);
 }
+function claudeActivityCall(name, input) {
+    if (!isRecord(input))
+        return { kind: "other", display: name };
+    return activityCallFromNamedTool(name, {
+        ...(typeof input.command === "string" ? { command: input.command } : {}),
+        ...(typeof input.description === "string" ? { description: input.description } : {}),
+        ...(typeof input.file_path === "string" ? { path: input.file_path } : {}),
+        ...(typeof input.offset === "number" && Number.isFinite(input.offset) ? { offset: input.offset } : {}),
+        ...(typeof input.limit === "number" && Number.isFinite(input.limit) ? { limit: input.limit } : {}),
+        ...(typeof input.query === "string" ? { query: input.query } : {}),
+    });
+}
+function claudeResultMessage(content) {
+    if (typeof content === "string")
+        return content ? boundActivityExcerpt(content) : undefined;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content.flatMap((entry) => {
+        if (!isRecord(entry) || entry.type !== "text" || typeof entry.text !== "string")
+            return [];
+        return [entry.text];
+    }).join("\n");
+    return text ? boundActivityExcerpt(text) : undefined;
+}
+function emitClaudeToolStarts(builder, event, seenToolUses) {
+    if (!Array.isArray(event.message.content))
+        return;
+    for (const block of event.message.content) {
+        if (!isRecord(block) || block.type !== "tool_use")
+            continue;
+        const id = coerceString(block.id);
+        const name = coerceString(block.name);
+        if (!id || !name)
+            continue;
+        const call = claudeActivityCall(name, block.input);
+        seenToolUses.set(id, { tool: name, call });
+        builder.emit({
+            type: "activity",
+            phase: "started",
+            id,
+            tool: name,
+            call,
+        });
+        if (name === "TodoWrite" && isRecord(block.input) && Array.isArray(block.input.todos)) {
+            const items = block.input.todos.slice(0, AGENT_PLAN_MAX_ITEMS).flatMap((todo) => {
+                if (!isRecord(todo) || typeof todo.content !== "string" || typeof todo.status !== "string") {
+                    return [];
+                }
+                return [{
+                        text: todo.content.slice(0, AGENT_PLAN_ITEM_TEXT_MAX_CHARS),
+                        done: todo.status === "completed",
+                        ...(todo.status === "in_progress" ? { active: true } : {}),
+                    }];
+            });
+            builder.emit({ type: "plan", id, items });
+        }
+    }
+}
+function emitClaudeThoughts(builder, event) {
+    if (!Array.isArray(event.message.content))
+        return;
+    event.message.content.forEach((block, blockIndex) => {
+        if (!isRecord(block) || block.type !== "thinking" || typeof block.thinking !== "string")
+            return;
+        const truncated = block.thinking.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+        builder.emit({
+            type: "thought",
+            id: `${event.uuid}:${blockIndex}`,
+            text: block.thinking.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+            final: true,
+            ...(truncated ? { truncated: true } : {}),
+        });
+    });
+}
+function emitClaudeToolResults(builder, event, seenToolUses) {
+    const content = event.message.content;
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        if (!isRecord(block) || block.type !== "tool_result")
+            continue;
+        const id = coerceString(block.tool_use_id);
+        if (!id)
+            continue;
+        const observed = seenToolUses.get(id);
+        if (!observed)
+            continue;
+        seenToolUses.delete(id);
+        const message = claudeResultMessage(block.content);
+        builder.emit({
+            type: "activity",
+            phase: "completed",
+            id,
+            tool: observed.tool,
+            call: observed.call,
+            result: {
+                status: block.is_error === true ? "error" : "ok",
+                ...(message ? { message } : {}),
+            },
+        });
+    }
+}
+function emitClaudeUsage(builder, event, model) {
+    const usage = event.usage;
+    builder.emit({
+        type: "usage",
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cachedInputTokens: usage.cache_read_input_tokens,
+        ...(typeof event.total_cost_usd === "number" ? { costUsd: event.total_cost_usd } : {}),
+        ...(model ? { model } : {}),
+    });
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -253,6 +392,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
     let completedResultOrdinal = 0;
     let openSteerCount = 0;
     let sawSuccessfulResult = false;
+    let emitTurnStarted;
     const activeWaiters = new Set();
     const notifyActive = () => {
         for (const resolve of [...activeWaiters]) {
@@ -305,7 +445,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 throw new Error(`${CLAUDE_AGENT_SDK_PROVIDER} cannot enqueue: query ended before yield`);
             }
             if (message.effort) {
-                await liveQuery.applyFlagSettings({ effortLevel: message.effort === "max" ? "xhigh" : message.effort });
+                await liveQuery.applyFlagSettings({ effortLevel: toClaudeSdkEffort(message.effort) });
             }
             // The pump calls enqueue at a successful result checkpoint. Push now;
             // waiting for another result before pushing would deadlock the next turn.
@@ -313,6 +453,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
             const submitted = inputStream.push(toUserMessage(message.text));
             // submitted = NEXT source next() after this tell is yielded (not the yield pull itself).
             await submitted.waitSubmitted();
+            emitTurnStarted?.();
             // 落账：记录提交时越过的 result ordinal（generation fence 落点）。
             const submittedAfterResultOrdinal = completedResultOrdinal;
             if (options.onEvidence)
@@ -326,7 +467,9 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
     };
     return createProjectionDriver({
         steerMode: "mid-execution",
+        initialTurn: options.initialTurn,
         enqueue,
+        onIngress: options.onIngress,
         async abort() {
             queryEnded = true;
             queryActive = false;
@@ -343,6 +486,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
         },
         async run(builder) {
             builderDiagnostic = (text) => builder.emit({ type: "diagnostic", text });
+            emitTurnStarted = () => builder.emit({ type: "turn", phase: "started" });
             while (pendingEvidenceDiagnostics > 0) {
                 pendingEvidenceDiagnostics -= 1;
                 builderDiagnostic("provider evidence callback failed");
@@ -366,12 +510,10 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                         emitProviderEvidence(options.onEvidence, { type: "outbound", provider: CLAUDE_AGENT_SDK_PROVIDER, direction: "input", kind: "steer", ...sha256Utf8(text) }, (text) => builder.emit({ type: "diagnostic", text }));
                 });
                 inputStream.push(initialMessage);
+                builder.emit({ type: "turn", phase: "started" });
                 const queryOptions = {
                     cwd,
                     model: options.model,
-                    permissionMode: options.permissionMode,
-                    allowDangerouslySkipPermissions: options.permissionMode === "bypassPermissions",
-                    settingSources: [...options.settingSources],
                     resume: sessionId,
                     env: buildSubagentEnv(),
                     abortController: queryAbortController,
@@ -381,10 +523,22 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                         builder.emit({ type: "diagnostic", text: data });
                     },
                 };
+                if (options.permissionMode !== undefined) {
+                    queryOptions.permissionMode = options.permissionMode;
+                    if (options.permissionMode === "bypassPermissions") {
+                        queryOptions.allowDangerouslySkipPermissions = true;
+                    }
+                }
+                if (options.settingSources !== undefined) {
+                    queryOptions.settingSources = [...options.settingSources];
+                }
+                if (options.disallowedTools !== undefined) {
+                    queryOptions.disallowedTools = [...options.disallowedTools];
+                }
                 const execPathKey = `pathToClaudeCode${"Ex"}ecutable`;
                 queryOptions[execPathKey] = options.executable;
                 if (options.effort !== undefined) {
-                    queryOptions.effort = options.effort;
+                    queryOptions.effort = toClaudeSdkEffort(options.effort);
                 }
                 // Long-lived push-AsyncIterable: one stream for the whole Query lifetime (Tier 1).
                 // Never mount short per-tell streams (that would endInput and break stdin).
@@ -400,87 +554,94 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 let resumedSessionId = sessionId;
                 let finalMessage;
                 let latestAssistantMessageModel;
+                const seenToolUses = new Map();
                 for await (const event of query) {
-                    builder.emit({ type: "output", value: event });
-                    resumedSessionId = extractResumeToken(event) ?? resumedSessionId;
-                    const overloadWarning = extractOverloadFallbackWarning(event);
-                    if (overloadWarning) {
-                        builder.emit({ type: "warning", warning: overloadWarning });
-                    }
-                    if (isClaudeModelRefusalFallbackEvent(event)) {
-                        builder.emit({
-                            type: "warning",
-                            warning: {
-                                reason: "refusal",
-                                originalModel: event.original_model,
-                                fallbackModel: event.fallback_model,
-                                direction: event.direction,
-                                requestId: event.request_id,
-                                ...(latestAssistantMessageModel ? { signerModel: latestAssistantMessageModel } : {}),
-                            },
-                        });
-                    }
-                    else if (isClaudeModelRefusalNoFallbackEvent(event)) {
-                        builder.emit({
-                            type: "warning",
-                            warning: {
-                                reason: "refusal",
-                                originalModel: event.original_model,
-                                requestId: event.request_id,
-                                ...(latestAssistantMessageModel ? { signerModel: latestAssistantMessageModel } : {}),
-                            },
-                        });
-                    }
-                    switch (event.type) {
-                        case "assistant": {
-                            latestAssistantMessageModel = extractAssistantMessageModel(event) ?? latestAssistantMessageModel;
-                            finalMessage = extractAssistantMessage(event) ?? finalMessage;
-                            if (finalMessage) {
-                                builder.emit({ type: "message", text: finalMessage });
-                            }
-                            break;
+                    builder.ingress(CLAUDE_AGENT_SDK_PROVIDER, event.type, event, claudeIngressDisposition(event.type), () => {
+                        resumedSessionId = extractResumeToken(event) ?? resumedSessionId;
+                        const overloadWarning = extractOverloadFallbackWarning(event);
+                        if (overloadWarning) {
+                            builder.emit({ type: "warning", warning: overloadWarning });
                         }
-                        case "result": {
-                            const resultText = extractResultText(event);
-                            if (event.subtype === "success") {
-                                finalMessage = resultText ?? finalMessage;
+                        if (isClaudeModelRefusalFallbackEvent(event)) {
+                            builder.emit({
+                                type: "warning",
+                                warning: {
+                                    reason: "refusal",
+                                    originalModel: event.original_model,
+                                    fallbackModel: event.fallback_model,
+                                    direction: event.direction,
+                                    requestId: event.request_id,
+                                    ...(latestAssistantMessageModel ? { signerModel: latestAssistantMessageModel } : {}),
+                                },
+                            });
+                        }
+                        else if (isClaudeModelRefusalNoFallbackEvent(event)) {
+                            builder.emit({
+                                type: "warning",
+                                warning: {
+                                    reason: "refusal",
+                                    originalModel: event.original_model,
+                                    requestId: event.request_id,
+                                    ...(latestAssistantMessageModel ? { signerModel: latestAssistantMessageModel } : {}),
+                                },
+                            });
+                        }
+                        switch (event.type) {
+                            case "assistant": {
+                                latestAssistantMessageModel = extractAssistantMessageModel(event) ?? latestAssistantMessageModel;
+                                emitClaudeThoughts(builder, event);
+                                emitClaudeToolStarts(builder, event, seenToolUses);
+                                finalMessage = extractAssistantMessage(event) ?? finalMessage;
                                 if (finalMessage) {
                                     builder.emit({ type: "message", text: finalMessage });
                                 }
-                                sawSuccessfulResult = true;
-                                // Advance generation fence BEFORE maybe-ending the stream so gated tells can yield.
-                                bumpResultOrdinal();
-                                const checkpoint = {
-                                    fence: { kind: "ordinal", ordinal: completedResultOrdinal },
-                                };
-                                // Record the native result before the synchronous pump can
-                                // consume any tell fenced to an earlier result.
-                                if (options.onEvidence) {
-                                    emitProviderEvidence(options.onEvidence, {
-                                        type: "checkpoint",
-                                        provider: CLAUDE_AGENT_SDK_PROVIDER,
-                                        ...checkpoint,
-                                        source: "response",
-                                    }, (text) => builder.emit({ type: "diagnostic", text }));
-                                }
-                                // Sync checkpoint: claim inbox tells and deliver them via steer control.
-                                options.onSyncCheckpoint?.({ enqueue }, checkpoint);
-                                // Defer end so concurrent enqueue after this result can register openSteerCount.
-                                queueMicrotask(() => maybeEndInputStream());
                                 break;
                             }
-                            bumpResultOrdinal();
-                            if (resultText) {
-                                builder.emit({ type: "diagnostic", text: resultText });
+                            case "user": {
+                                emitClaudeToolResults(builder, event, seenToolUses);
+                                break;
                             }
-                            const message = resultText ?? `${CLAUDE_AGENT_SDK_PROVIDER} exec failed`;
-                            builder.emit({ type: "fail", message });
-                            inputStream.end();
-                            throw new Error(message);
+                            case "result": {
+                                const resultText = extractResultText(event);
+                                if (event.subtype === "success") {
+                                    finalMessage = resultText ?? finalMessage;
+                                    emitClaudeUsage(builder, event, latestAssistantMessageModel);
+                                    builder.emit({ type: "turn", phase: "completed" });
+                                    sawSuccessfulResult = true;
+                                    // Advance generation fence BEFORE maybe-ending the stream so gated tells can yield.
+                                    bumpResultOrdinal();
+                                    const checkpoint = {
+                                        fence: { kind: "ordinal", ordinal: completedResultOrdinal },
+                                    };
+                                    // Record the native result before the synchronous pump can
+                                    // consume any tell fenced to an earlier result.
+                                    if (options.onEvidence) {
+                                        emitProviderEvidence(options.onEvidence, {
+                                            type: "checkpoint",
+                                            provider: CLAUDE_AGENT_SDK_PROVIDER,
+                                            ...checkpoint,
+                                            source: "response",
+                                        }, (text) => builder.emit({ type: "diagnostic", text }));
+                                    }
+                                    // Sync checkpoint: claim inbox tells and deliver them via steer control.
+                                    options.onSyncCheckpoint?.({ enqueue }, checkpoint);
+                                    // Defer end so concurrent enqueue after this result can register openSteerCount.
+                                    queueMicrotask(() => maybeEndInputStream());
+                                    break;
+                                }
+                                bumpResultOrdinal();
+                                if (resultText) {
+                                    builder.emit({ type: "diagnostic", text: resultText });
+                                }
+                                const message = resultText ?? `${CLAUDE_AGENT_SDK_PROVIDER} exec failed`;
+                                builder.emit({ type: "fail", message });
+                                inputStream?.end();
+                                throw new Error(message);
+                            }
+                            default:
+                                break;
                         }
-                        default:
-                            break;
-                    }
+                    });
                 }
                 if (queryAbortController.signal.aborted) {
                     throw createAbortError(`${CLAUDE_AGENT_SDK_PROVIDER} exec cancelled by client`);