@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/agents/providers/{claude-agent-sdk.js → claude-agent-sdk/adapter.js}

@@ -1,380 +1,33 @@
 import { z } from "zod";
-import { appendDebugLog } from "../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION } from "../session.js";
-import { createProjectionDriver } from "../harness/execution-handle.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";
-}
+import { appendDebugLog } from "../../../telemetry/debug-log.js";
+import { SUBAGENT_SESSION_VERSION } from "../../session.js";
+import { createProjectionDriver } from "../../harness/execution-handle.js";
+import { buildSubagentEnv, createAbortError, emitProviderEvidence, linkAbortSignal, sha256Utf8 } from "../../harness/runtime.js";
+import { SubagentFailure } from "../../types.js";
+import { claudeIngressDisposition, emitClaudeThoughts, emitClaudeToolResults, emitClaudeToolStarts, emitClaudeUsage, extractAssistantMessage, extractAssistantMessageId, extractAssistantMessageModel, extractOverloadFallbackWarning, extractResultText, extractResumeToken, isClaudeApiRetryEvent, isClaudeModelRefusalFallbackEvent, isClaudeModelRefusalNoFallbackEvent, mapClaudeApiRetryWarning, } from "./events.js";
+import { CLAUDE_AGENT_SDK_PROVIDER, createPushableUserMessageStream, toClaudeUserMessage, } from "./session.js";
 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;
-/** Sentinel for IteratorResult<SDKUserMessage> done=true returns.
- * The SDK's AsyncIterator protocol requires the value field even when done=true.
- * Consumers never read it, but TypeScript needs the type to match. */
-const DONE_SENTINEL = undefined;
-function extractMessageText(content) {
-    if (!Array.isArray(content))
-        return undefined;
-    const text = content
-        .map((block) => {
-        if (typeof block !== "object" || block === null || !("text" in block))
-            return "";
-        const candidate = block.text;
-        return typeof candidate === "string" ? candidate : "";
-    })
-        .join("")
-        .trim();
-    return text || undefined;
-}
-function extractAssistantMessage(event) {
-    return extractMessageText(event.message.content);
-}
-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;
-}
-function isClaudeModelRefusalFallbackEvent(event) {
-    return event.type === "system" && event.subtype === "model_refusal_fallback";
-}
-function isClaudeModelRefusalNoFallbackEvent(event) {
-    return event.type === "system" && event.subtype === "model_refusal_no_fallback";
-}
-function extractFallbackRequestId(value) {
-    if (value === null)
-        return null;
-    return coerceString(value);
-}
-function extractOverloadFallbackWarning(event) {
-    if (!isRecord(event) || event.type !== "fallback") {
-        return undefined;
-    }
-    const originalModel = coerceString(event.original_model);
-    const fallbackModel = coerceString(event.fallback_model);
-    const direction = coerceString(event.direction);
-    const requestId = extractFallbackRequestId(event.request_id);
-    return {
-        reason: "overload",
-        ...(originalModel ? { originalModel } : {}),
-        ...(fallbackModel ? { fallbackModel } : {}),
-        ...(direction ? { direction } : {}),
-        ...(requestId !== undefined ? { requestId } : {}),
-    };
-}
-function extractResumeToken(event) {
-    return coerceString(event.session_id);
-}
-function extractResultText(event) {
-    if (event.subtype === "success") {
-        return coerceString(event.result);
+async function loadClaudeAgentSdk(loader) {
+    if (loader) {
+        return loader();
     }
-    const errorText = event.errors.join("\n").trim();
-    return errorText || undefined;
-}
-async function loadClaudeAgentSdk() {
     if (claudeAgentSdkLoader) {
         return claudeAgentSdkLoader();
     }
     return (await import("@anthropic-ai/claude-agent-sdk"));
 }
+/** @deprecated Use ClaudeProviderOptions.loader instead. Kept for pipeline-based tests pending loader channel. */
 export function setClaudeAgentSdkLoaderForTests(loader) {
     claudeAgentSdkLoader = loader;
 }
+/** @deprecated Use ClaudeProviderOptions.loader instead. */
 export function resetClaudeAgentSdkLoaderForTests() {
     claudeAgentSdkLoader = undefined;
 }
-function createMessageAck() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    // Prevent unhandled rejection if nobody awaits before reject-on-end.
-    promise.catch(() => undefined);
-    const ack = {
-        settled: false,
-        settleResolve() {
-            if (ack.settled)
-                return;
-            ack.settled = true;
-            resolve();
-        },
-        settleReject(error) {
-            if (ack.settled)
-                return;
-            ack.settled = true;
-            reject(error);
-        },
-        wait() {
-            return promise;
-        },
-    };
-    return ack;
-}
-/**
- * Long-lived push source for Claude Query.
- * Submitted fence is per-yield: entering next() first acknowledges the previously
- * yielded message, then yields the next item. That next-entry after a yield is the
- * post-yield ack (transport.write completed for the prior yield).
- */
-export function createPushableUserMessageStream(onYield) {
-    const queue = [];
-    const waiters = [];
-    /** Ack for the message most recently yielded; resolved on the subsequent next() entry. */
-    let pendingYieldAck;
-    let closed = false;
-    let failure;
-    let pullCount = 0;
-    const terminalError = (error) => error ?? new Error(`${CLAUDE_AGENT_SDK_PROVIDER} input stream ended before submitted ack`);
-    const rejectUnresolvedAcks = (error) => {
-        const err = terminalError(error);
-        if (pendingYieldAck) {
-            pendingYieldAck.settleReject(err);
-            pendingYieldAck = undefined;
-        }
-        while (queue.length > 0) {
-            queue.shift().ack.settleReject(err);
-        }
-    };
-    /** First action on every next() entry: post-yield ack for the prior yield. */
-    const acknowledgePreviousYield = () => {
-        if (!pendingYieldAck)
-            return;
-        pendingYieldAck.settleResolve();
-        pendingYieldAck = undefined;
-    };
-    const yieldQueued = (entry) => {
-        pullCount += 1;
-        pendingYieldAck = entry.ack;
-        onYield?.(entry.message);
-        return { value: entry.message, done: false };
-    };
-    return {
-        get pullCount() {
-            return pullCount;
-        },
-        get queueLength() {
-            return queue.length;
-        },
-        push(message) {
-            const ack = createMessageAck();
-            if (closed || failure !== undefined) {
-                ack.settleReject(terminalError(failure));
-                return { waitSubmitted: () => ack.wait() };
-            }
-            const waiter = waiters.shift();
-            if (waiter) {
-                // Consumer is already inside next() (previous yield already acked at entry).
-                pullCount += 1;
-                pendingYieldAck = ack;
-                onYield?.(message);
-                waiter.resolve({ value: message, done: false });
-                return { waitSubmitted: () => ack.wait() };
-            }
-            queue.push({ message, ack });
-            return { waitSubmitted: () => ack.wait() };
-        },
-        end(error) {
-            if (closed)
-                return;
-            closed = true;
-            if (error !== undefined) {
-                failure = error;
-                // Failure: reject every unresolved ack (yielded + still queued) so enqueue cannot hang.
-                rejectUnresolvedAcks(error);
-                while (waiters.length > 0) {
-                    waiters.shift().reject(failure);
-                }
-                return;
-            }
-            // Clean end: leave queued messages readable for a late consumer drain.
-            // Only reject a yielded-but-not-post-acked message (no further next() will ack it
-            // if the consumer has already stopped). If a consumer is parked, they get done
-            // after any remaining queue is taken on subsequent next() calls — parked waiters
-            // here mean queue is empty, so resolve done.
-            if (pendingYieldAck) {
-                pendingYieldAck.settleReject(terminalError());
-                pendingYieldAck = undefined;
-            }
-            while (waiters.length > 0) {
-                waiters.shift().resolve({ value: DONE_SENTINEL, done: true });
-            }
-        },
-        iterable: {
-            [Symbol.asyncIterator]() {
-                return {
-                    next() {
-                        // Per-yield submitted fence: next entry acks the previously yielded message.
-                        acknowledgePreviousYield();
-                        if (queue.length > 0) {
-                            return Promise.resolve(yieldQueued(queue.shift()));
-                        }
-                        if (failure !== undefined) {
-                            return Promise.reject(failure);
-                        }
-                        if (closed) {
-                            return Promise.resolve({ value: DONE_SENTINEL, done: true });
-                        }
-                        return new Promise((resolve, reject) => {
-                            waiters.push({ resolve, reject });
-                        });
-                    },
-                };
-            },
-        },
-    };
-}
-function toUserMessage(text) {
-    return {
-        type: "user",
-        message: {
-            role: "user",
-            content: text,
-        },
-        parent_tool_use_id: null,
-        session_id: "",
-    };
-}
 export async function startClaudeAgentSdk(prompt, cwd, options) {
     const sessionId = options.sessionId?.trim();
     let liveQuery;
@@ -450,7 +103,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
             // The pump calls enqueue at a successful result checkpoint. Push now;
             // waiting for another result before pushing would deadlock the next turn.
             // text is already core-rendered; send byte-for-byte. id is for the frame only (inside text).
-            const submitted = inputStream.push(toUserMessage(message.text));
+            const submitted = inputStream.push(toClaudeUserMessage(message.text));
             // submitted = NEXT source next() after this tell is yielded (not the yield pull itself).
             await submitted.waitSubmitted();
             emitTurnStarted?.();
@@ -470,10 +123,16 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
         initialTurn: options.initialTurn,
         enqueue,
         onIngress: options.onIngress,
-        async abort() {
+        async abort(mode) {
             queryEnded = true;
             queryActive = false;
             const abortError = createAbortError(`${CLAUDE_AGENT_SDK_PROVIDER} exec cancelled by client`);
+            if (mode === "force") {
+                inputStream?.end(abortError);
+                rejectPendingEnqueueWaiters(abortError);
+                liveQuery?.close();
+                return;
+            }
             try {
                 await liveQuery?.interrupt();
             }
@@ -491,12 +150,12 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 pendingEvidenceDiagnostics -= 1;
                 builderDiagnostic("provider evidence callback failed");
             }
-            const sdk = await loadClaudeAgentSdk();
+            const sdk = await loadClaudeAgentSdk(options.loader);
             const queryAbortController = new AbortController();
             const unlinkBuilderAbort = linkAbortSignal(builder.signal, queryAbortController, () => undefined);
             const unlinkOuterAbort = linkAbortSignal(options.signal, queryAbortController, () => undefined);
             try {
-                const initialMessage = toUserMessage(prompt);
+                const initialMessage = toClaudeUserMessage(prompt);
                 inputStream = createPushableUserMessageStream((message) => {
                     if (!options.onEvidence)
                         return;
@@ -515,7 +174,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                     cwd,
                     model: options.model,
                     resume: sessionId,
-                    env: buildSubagentEnv(),
+                    env: buildSubagentEnv(options.env),
                     abortController: queryAbortController,
                     persistSession: true,
                     ...(options.systemPrompt ? { systemPrompt: options.systemPrompt } : {}),
@@ -554,10 +213,23 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 let resumedSessionId = sessionId;
                 let finalMessage;
                 let latestAssistantMessageModel;
+                // Provider acceptance / pre-terminal retry evidence for no-turn classification.
+                // turn.started is a harness-local pre-query event and is not acceptance.
+                let acceptedTurn = false;
+                let lastPreTerminalEvidenceWasRetry = false;
                 const seenToolUses = new Map();
                 for await (const event of query) {
                     builder.ingress(CLAUDE_AGENT_SDK_PROVIDER, event.type, event, claudeIngressDisposition(event.type), () => {
                         resumedSessionId = extractResumeToken(event) ?? resumedSessionId;
+                        if (isClaudeApiRetryEvent(event)) {
+                            lastPreTerminalEvidenceWasRetry = true;
+                            builder.emit({ type: "warning", warning: mapClaudeApiRetryWarning(event) });
+                        }
+                        else if (!(event.type === "result" && event.subtype !== "success")) {
+                            // Any other non-terminal-failure native event clears the last-retry predicate.
+                            // Failed result itself is terminal and must not overwrite prior evidence.
+                            lastPreTerminalEvidenceWasRetry = false;
+                        }
                         const overloadWarning = extractOverloadFallbackWarning(event);
                         if (overloadWarning) {
                             builder.emit({ type: "warning", warning: overloadWarning });
@@ -588,22 +260,25 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                         }
                         switch (event.type) {
                             case "assistant": {
+                                acceptedTurn = true;
                                 latestAssistantMessageModel = extractAssistantMessageModel(event) ?? latestAssistantMessageModel;
                                 emitClaudeThoughts(builder, event);
                                 emitClaudeToolStarts(builder, event, seenToolUses);
                                 finalMessage = extractAssistantMessage(event) ?? finalMessage;
                                 if (finalMessage) {
-                                    builder.emit({ type: "message", text: finalMessage });
+                                    builder.emit({ type: "message", id: extractAssistantMessageId(event), text: finalMessage });
                                 }
                                 break;
                             }
                             case "user": {
+                                acceptedTurn = true;
                                 emitClaudeToolResults(builder, event, seenToolUses);
                                 break;
                             }
                             case "result": {
                                 const resultText = extractResultText(event);
                                 if (event.subtype === "success") {
+                                    acceptedTurn = true;
                                     finalMessage = resultText ?? finalMessage;
                                     emitClaudeUsage(builder, event, latestAssistantMessageModel);
                                     builder.emit({ type: "turn", phase: "completed" });
@@ -612,6 +287,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                                     bumpResultOrdinal();
                                     const checkpoint = {
                                         fence: { kind: "ordinal", ordinal: completedResultOrdinal },
+                                        consumptionEvidence: true,
                                     };
                                     // Record the native result before the synchronous pump can
                                     // consume any tell fenced to an earlier result.
@@ -619,7 +295,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                                         emitProviderEvidence(options.onEvidence, {
                                             type: "checkpoint",
                                             provider: CLAUDE_AGENT_SDK_PROVIDER,
-                                            ...checkpoint,
+                                            fence: checkpoint.fence,
                                             source: "response",
                                         }, (text) => builder.emit({ type: "diagnostic", text }));
                                     }
@@ -634,9 +310,11 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                                     builder.emit({ type: "diagnostic", text: resultText });
                                 }
                                 const message = resultText ?? `${CLAUDE_AGENT_SDK_PROVIDER} exec failed`;
-                                builder.emit({ type: "fail", message });
+                                const unavailable = !acceptedTurn && lastPreTerminalEvidenceWasRetry;
+                                const failCode = unavailable ? "SUBAGENT_PROVIDER_UNAVAILABLE" : "SUBAGENT_EXEC_ERROR";
+                                builder.emit({ type: "fail", message, code: failCode });
                                 inputStream?.end();
-                                throw new Error(message);
+                                throw new SubagentFailure(failCode, message);
                             }
                             default:
                                 break;