@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,396 +0,0 @@
-import { appendDebugLog } from "../../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION } from "../../session.js";
-import { createProjectionDriver } from "../../harness/execution-handle.js";
-import { exactLaunchInputReceipts } from "../../harness/control-types.js";
-import { createProviderFailure } from "../../harness/provider-adapter.js";
-import { awaitProviderAbortSettlement, buildSubagentEnv, createAbortError, emitProviderEvidence, linkAbortSignal, sha256Utf8 } from "../../harness/runtime.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 { claudeSessionSchema } from "./session-schema.js";
-async function loadClaudeAgentSdk(loader) {
-    if (loader) {
-        return loader();
-    }
-    return (await import("@anthropic-ai/claude-agent-sdk"));
-}
-export async function startClaudeAgentSdk(prompt, cwd, options) {
-    const sessionId = options.sessionId?.trim();
-    let liveQuery;
-    let queryAbortController;
-    let runStarted = false;
-    let settleRun;
-    const runSettled = new Promise((resolve) => { settleRun = resolve; });
-    let pendingEvidenceDiagnostics = 0;
-    let builderDiagnostic = () => {
-        pendingEvidenceDiagnostics += 1;
-        appendDebugLog("provider evidence callback failed before Claude driver start", {
-            cwd,
-            section: CLAUDE_AGENT_SDK_PROVIDER,
-        });
-    };
-    let inputStream;
-    let queryActive = false;
-    let queryEnded = false;
-    let completedResultOrdinal = 0;
-    let openSteerCount = 0;
-    let sawSuccessfulResult = false;
-    let emitTurnStarted;
-    const activeWaiters = new Set();
-    const notifyActive = () => {
-        for (const resolve of [...activeWaiters]) {
-            activeWaiters.delete(resolve);
-            resolve();
-        }
-    };
-    const waitUntilQueryActive = async () => {
-        if (queryActive && inputStream && liveQuery)
-            return;
-        if (queryEnded) {
-            throw new Error(`${CLAUDE_AGENT_SDK_PROVIDER} cannot enqueue: query ended`);
-        }
-        await new Promise((resolve) => {
-            activeWaiters.add(resolve);
-        });
-        if (!queryActive || !inputStream || !liveQuery) {
-            throw new Error(`${CLAUDE_AGENT_SDK_PROVIDER} cannot enqueue: query is not active`);
-        }
-    };
-    const bumpResultOrdinal = () => {
-        completedResultOrdinal += 1;
-    };
-    const rejectPendingEnqueueWaiters = (_error) => {
-        for (const resolve of [...activeWaiters]) {
-            activeWaiters.delete(resolve);
-            resolve();
-        }
-    };
-    const maybeEndInputStream = () => {
-        if (!inputStream)
-            return;
-        if (openSteerCount > 0)
-            return;
-        if (inputStream.queueLength > 0)
-            return;
-        if (!sawSuccessfulResult)
-            return;
-        inputStream.end();
-    };
-    appendDebugLog(`startClaudeAgentSdk: executable=${options.executable} model=${options.model ?? "default"} mode=${sessionId ? "resume" : "fresh"}`, { cwd, section: CLAUDE_AGENT_SDK_PROVIDER });
-    const enqueue = async (message) => {
-        // Reserve the stream before awaiting activation so the result checkpoint's
-        // deferred close cannot race a mailbox delivery queued in that checkpoint.
-        openSteerCount += 1;
-        try {
-            // Projection may be returned before run() arms the long-lived Query; wait, do not race-fail.
-            await waitUntilQueryActive();
-            if (!inputStream || !liveQuery || queryEnded) {
-                throw new Error(`${CLAUDE_AGENT_SDK_PROVIDER} cannot enqueue: query ended before yield`);
-            }
-            if (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.
-            // text is already core-rendered; send byte-for-byte. id is for the frame only (inside 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();
-            options.onTellReceipt?.({ stage: "seen", correlation: { kind: "exact", tellId: message.id } });
-            emitTurnStarted?.();
-            // 落账：记录提交时越过的 result ordinal（generation fence 落点）。
-            const submittedAfterResultOrdinal = completedResultOrdinal;
-            if (options.onEvidence)
-                emitProviderEvidence(options.onEvidence, { type: "ack", provider: CLAUDE_AGENT_SDK_PROVIDER, fence: { kind: "ordinal", ordinal: submittedAfterResultOrdinal }, outbound: "steer" }, builderDiagnostic);
-            return { fence: { kind: "ordinal", ordinal: submittedAfterResultOrdinal } };
-        }
-        finally {
-            openSteerCount -= 1;
-            maybeEndInputStream();
-        }
-    };
-    return createProjectionDriver({
-        steerMode: "mid-execution",
-        initialTurn: options.initialTurn,
-        enqueue,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            queryEnded = true;
-            queryActive = false;
-            const abortError = createAbortError(`${CLAUDE_AGENT_SDK_PROVIDER} exec cancelled by client`);
-            if (mode === "force") {
-                queryAbortController?.abort(abortError);
-                inputStream?.end(abortError);
-                rejectPendingEnqueueWaiters(abortError);
-                liveQuery?.close();
-                if (runStarted) {
-                    await awaitProviderAbortSettlement(CLAUDE_AGENT_SDK_PROVIDER, runSettled, "forced query teardown did not settle");
-                }
-                return;
-            }
-            try {
-                await liveQuery?.interrupt();
-            }
-            catch {
-                // interrupt is best-effort acceleration for dismiss/abort only
-            }
-            liveQuery?.close();
-            inputStream?.end(abortError);
-            rejectPendingEnqueueWaiters(abortError);
-            if (runStarted) {
-                await awaitProviderAbortSettlement(CLAUDE_AGENT_SDK_PROVIDER, runSettled, "graceful query teardown did not settle");
-            }
-        },
-        async run(builder) {
-            runStarted = true;
-            builderDiagnostic = (text) => builder.emit({ type: "diagnostic", text });
-            emitTurnStarted = () => builder.emit({ type: "turn", phase: "started" });
-            while (pendingEvidenceDiagnostics > 0) {
-                pendingEvidenceDiagnostics -= 1;
-                builderDiagnostic("provider evidence callback failed");
-            }
-            const sdk = await loadClaudeAgentSdk(options.loader);
-            queryAbortController = new AbortController();
-            const unlinkBuilderAbort = linkAbortSignal(builder.signal, queryAbortController, () => undefined);
-            const unlinkOuterAbort = linkAbortSignal(options.signal, queryAbortController, () => undefined);
-            try {
-                const initialMessage = toClaudeUserMessage(prompt);
-                inputStream = createPushableUserMessageStream(async (message) => {
-                    if (message === initialMessage) {
-                        // Claude's source pull is the provider-native launch-input fact.
-                        // The adapter records its coordinate before asking heart to reduce
-                        // the exact attributed receipt.
-                        const fence = { kind: "ordinal", ordinal: 0 };
-                        await options.onLaunchAdmission?.({ fence, tellIds: options.launchTellIds ?? [] });
-                        const admissions = (options.listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && admission.fence.ordinal === fence.ordinal));
-                        for (const receipt of exactLaunchInputReceipts("seen", fence, admissions))
-                            options.onTellReceipt?.(receipt);
-                        return;
-                    }
-                    if (!options.onEvidence)
-                        return;
-                    const content = message.message.content;
-                    const text = typeof content === "string"
-                        ? content
-                        : content.map((block) => typeof block === "object" && block !== null && "text" in block && typeof block.text === "string" ? block.text : "").join("");
-                    if (text)
-                        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,
-                    resume: sessionId,
-                    env: buildSubagentEnv(options.env),
-                    abortController: queryAbortController,
-                    persistSession: true,
-                    ...(options.systemPrompt ? { systemPrompt: options.systemPrompt } : {}),
-                    stderr: (data) => {
-                        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 = 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).
-                if (options.onEvidence && options.systemPrompt)
-                    emitProviderEvidence(options.onEvidence, { type: "outbound", provider: CLAUDE_AGENT_SDK_PROVIDER, direction: "input", kind: "system-prompt", ...sha256Utf8(options.systemPrompt.append) }, (text) => builder.emit({ type: "diagnostic", text }));
-                const query = sdk.query({
-                    prompt: inputStream.iterable,
-                    options: queryOptions,
-                });
-                liveQuery = query;
-                queryActive = true;
-                notifyActive();
-                let resumedSessionId = sessionId;
-                let admittedSessionId;
-                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), () => {
-                        const providerSessionId = extractResumeToken(event);
-                        resumedSessionId = providerSessionId ?? resumedSessionId;
-                        if (providerSessionId && providerSessionId !== admittedSessionId) {
-                            admittedSessionId = providerSessionId;
-                            options.onSessionAdmission?.({
-                                session: {
-                                    provider: CLAUDE_AGENT_SDK_PROVIDER,
-                                    version: SUBAGENT_SESSION_VERSION,
-                                    handle: { sessionId: providerSessionId },
-                                },
-                            });
-                        }
-                        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 });
-                        }
-                        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": {
-                                acceptedTurn = true;
-                                latestAssistantMessageModel = extractAssistantMessageModel(event) ?? latestAssistantMessageModel;
-                                emitClaudeThoughts(builder, event);
-                                emitClaudeToolStarts(builder, event, seenToolUses);
-                                finalMessage = extractAssistantMessage(event) ?? finalMessage;
-                                if (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" });
-                                    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,
-                                            fence: checkpoint.fence,
-                                            source: "response",
-                                        }, (text) => builder.emit({ type: "diagnostic", text }));
-                                    }
-                                    // Sync checkpoint: claim inbox tells and deliver them via steer control.
-                                    options.onSyncCheckpoint?.({ enqueue }, checkpoint);
-                                    const admissions = (options.listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && admission.fence.ordinal < checkpoint.fence.ordinal));
-                                    for (const receipt of exactLaunchInputReceipts("consumed", checkpoint.fence, admissions))
-                                        options.onTellReceipt?.(receipt);
-                                    options.onTellReceipt?.({ stage: "consumed", correlation: { kind: "fence", fence: checkpoint.fence } });
-                                    // 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`;
-                                const unavailable = !acceptedTurn && lastPreTerminalEvidenceWasRetry;
-                                const failCode = unavailable ? "SUBAGENT_PROVIDER_UNAVAILABLE" : "SUBAGENT_EXEC_ERROR";
-                                builder.emit({ type: "fail", message, code: failCode });
-                                inputStream?.end();
-                                throw createProviderFailure(message, { code: failCode });
-                            }
-                            default:
-                                break;
-                        }
-                    });
-                }
-                if (queryAbortController.signal.aborted) {
-                    throw createAbortError(`${CLAUDE_AGENT_SDK_PROVIDER} exec cancelled by client`);
-                }
-                if (!resumedSessionId) {
-                    const message = `${CLAUDE_AGENT_SDK_PROVIDER} exec could not determine session id`;
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                const session = {
-                    provider: "claude-agent-sdk",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: { sessionId: resumedSessionId },
-                };
-                if (options.onEvidence)
-                    emitProviderEvidence(options.onEvidence, { type: "session", provider: CLAUDE_AGENT_SDK_PROVIDER, sessionId: resumedSessionId }, (text) => builder.emit({ type: "diagnostic", text }));
-                const resolvedFinal = finalMessage ?? "";
-                builder.emit({
-                    type: "done",
-                    finalMessage: resolvedFinal,
-                    session,
-                });
-                // Clean end on success: do not reject the stream (that would poison completion).
-                // Any still-pending enqueue waiters are rejected below as "query ended".
-                inputStream?.end();
-                return { finalMessage: resolvedFinal, session };
-            }
-            finally {
-                unlinkBuilderAbort?.();
-                unlinkOuterAbort?.();
-                queryEnded = true;
-                queryActive = false;
-                liveQuery = undefined;
-                // Unblock any mid-flight enqueue/generation waiters without throwing from run().
-                const endError = new Error(`${CLAUDE_AGENT_SDK_PROVIDER} query ended`);
-                if (inputStream) {
-                    // If abort/failure already ended with an error, this is a no-op (closed).
-                    // If success path already clean-ended, also a no-op.
-                    // If we exited via throw before clean end, reject unresolved post-yield acks.
-                    inputStream.end(endError);
-                }
-                rejectPendingEnqueueWaiters(endError);
-                settleRun();
-            }
-        },
-    });
-}
-// Compiler-level binding to the named ProviderAdapter function contract.
-startClaudeAgentSdk;

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

@@ -1,218 +0,0 @@
-import { activityCallFromNamedTool, boundActivityExcerpt } from "../../harness/activity-values.js";
-import { coerceString } from "../../harness/runtime.js";
-import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
-import { CLAUDE_AGENT_SDK_PROVIDER } from "./session.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",
-]);
-export function claudeIngressDisposition(type) {
-    if (CLAUDE_MAPPED.has(type))
-        return "mapped";
-    if (CLAUDE_ACKNOWLEDGED_UNPERSISTED.has(type))
-        return "acknowledged-unpersisted";
-    return "unknown";
-}
-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;
-}
-export function extractAssistantMessage(event) {
-    return extractMessageText(event.message.content);
-}
-export function extractAssistantMessageId(event) {
-    const id = coerceString(event.message.id)?.trim();
-    if (!id) {
-        throw Object.assign(new Error(`${CLAUDE_AGENT_SDK_PROVIDER} assistant event lacked nonblank message.id`), { name: "ClaudeAssistantMessageIdError" });
-    }
-    return id;
-}
-export 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;
-}
-export 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 });
-        }
-    }
-}
-export 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 } : {}),
-        });
-    });
-}
-export 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 } : {}),
-            },
-        });
-    }
-}
-export 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;
-}
-export function isClaudeModelRefusalFallbackEvent(event) {
-    return event.type === "system" && event.subtype === "model_refusal_fallback";
-}
-export function isClaudeModelRefusalNoFallbackEvent(event) {
-    return event.type === "system" && event.subtype === "model_refusal_no_fallback";
-}
-export function isClaudeApiRetryEvent(event) {
-    return event.type === "system" && event.subtype === "api_retry";
-}
-export function mapClaudeApiRetryWarning(event) {
-    return {
-        reason: "retry",
-        attempt: event.attempt,
-        maxRetries: event.max_retries,
-        retryDelayMs: event.retry_delay_ms,
-        errorStatus: event.error_status,
-    };
-}
-function extractFallbackRequestId(value) {
-    if (value === null)
-        return null;
-    return coerceString(value);
-}
-export 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 } : {}),
-    };
-}
-export function extractResumeToken(event) {
-    return coerceString(event.session_id);
-}
-export function extractResultText(event) {
-    if (event.subtype === "success") {
-        return coerceString(event.result);
-    }
-    const errorText = event.errors.join("\n").trim();
-    return errorText || undefined;
-}