@astrosheep/keiyaku 2.8.4 → 2.9.0

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

@@ -0,0 +1,218 @@
+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;
+}

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

@@ -0,0 +1,158 @@
+export const CLAUDE_AGENT_SDK_PROVIDER = "claude-agent-sdk";
+/** 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 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 });
+                        });
+                    },
+                };
+            },
+        },
+    };
+}
+export function toClaudeUserMessage(text) {
+    return {
+        type: "user",
+        message: {
+            role: "user",
+            content: text,
+        },
+        parent_tool_use_id: null,
+        session_id: "",
+    };
+}