@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/agents/call-terms.js

@@ -1,32 +0,0 @@
-import { getConfig } from "../config/env.js";
-import { getProviderRegistration } from "./providers/registry.js";
-export function buildCallTerms(snapshot, prompt, cwd, options) {
-    const runtimeConfig = getConfig();
-    const body = snapshot.akuma.body;
-    const registration = getProviderRegistration(snapshot.provider.kind);
-    const sessionContinuationPromptPrefix = body && registration.sessionContinuationPromptPrefix
-        ? registration.sessionContinuationPromptPrefix(body)
-        : "";
-    const replayPrompt = sessionContinuationPromptPrefix
-        ? `${sessionContinuationPromptPrefix}${prompt}`
-        : prompt;
-    const baseTerms = {
-        workdir: cwd,
-        prompt,
-        sessionContinuationPromptPrefix,
-        idleTimeoutMs: options.idleTimeoutMs ?? runtimeConfig.subagent.execIdleTimeoutMs,
-        executionTimeoutMs: options.executionTimeoutMs ?? runtimeConfig.subagent.execMaxDurationMs,
-        maxCaptureChars: registration.maxCaptureChars(runtimeConfig),
-        signal: options.signal,
-        ...(options.initialTurn !== undefined ? { initialTurn: options.initialTurn } : {}),
-        ...(options.carrier !== undefined ? { carrier: options.carrier } : {}),
-    };
-    // Live registry only admits CallTerms-producing contributions; the open
-    // registration surface returns structural RegistrationCallTerms.
-    return registration.buildCallTerms({
-        snapshot,
-        baseTerms,
-        body,
-        replayPrompt,
-    });
-}

package/build/agents/harness/activity-values.js

@@ -1,70 +0,0 @@
-import { AGENT_EVENT_TEXT_MAX_CHARS } from "./events.js";
-function toolKey(tool) {
-    return tool.toLowerCase().replace(/[-_\s]/g, "");
-}
-/** Classify already-extracted provider facts. This function never reads a provider payload. */
-export function activityCallFromNamedTool(tool, facts) {
-    switch (toolKey(tool)) {
-        case "bash":
-        case "shell":
-        case "commandexecution":
-            return facts.command
-                ? { kind: "run", command: facts.command, ...(facts.description ? { description: facts.description } : {}) }
-                : { kind: "other", display: tool };
-        case "read":
-            return facts.path
-                ? {
-                    kind: "read",
-                    path: facts.path,
-                    ...(facts.offset === undefined && facts.limit === undefined
-                        ? {}
-                        : { range: { ...(facts.offset === undefined ? {} : { offset: facts.offset }), ...(facts.limit === undefined ? {} : { limit: facts.limit }) } }),
-                }
-                : { kind: "other", display: tool };
-        case "write":
-            return facts.path
-                ? { kind: "fileChange", changes: [{ op: "add", path: facts.path }] }
-                : { kind: "other", display: tool };
-        case "edit":
-            return facts.path
-                ? { kind: "fileChange", changes: [{ op: "update", path: facts.path }] }
-                : { kind: "other", display: tool };
-        case "websearch":
-        case "search":
-            return facts.query
-                ? { kind: "search", query: facts.query }
-                : { kind: "other", display: tool };
-        default:
-            return { kind: "other", display: tool };
-    }
-}
-export function boundActivityExcerpt(value) {
-    return value.slice(-AGENT_EVENT_TEXT_MAX_CHARS);
-}
-/** True only for text that carries at least one unified-diff hunk header. */
-function hasUnifiedDiffHunk(patch) {
-    for (const line of patch.split("\n")) {
-        // Native app-server updates and ordinary unified patches use: @@ -a[,b] +c[,d] @@
-        if (/^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/.test(line))
-            return true;
-    }
-    return false;
-}
-/**
- * Count additions/deletions from provider-supplied unified patch text only.
- * Raw file contents (native add/delete `diff`) are rejected even when individual
- * lines happen to begin with `+` or `-`.
- */
-export function diffstatFromUnifiedPatch(patch) {
-    if (!hasUnifiedDiffHunk(patch))
-        return undefined;
-    let additions = 0;
-    let deletions = 0;
-    for (const line of patch.split("\n")) {
-        if (line.startsWith("+") && !line.startsWith("+++"))
-            additions += 1;
-        if (line.startsWith("-") && !line.startsWith("---"))
-            deletions += 1;
-    }
-    return additions || deletions ? { additions, deletions } : undefined;
-}

package/build/agents/harness/control-types.js

@@ -1,18 +0,0 @@
-/**
- * Adapters call this only with durable admissions their native event proved.
- * A duplicate tell coordinate is ambiguous and intentionally yields no receipt.
- */
-export function exactLaunchInputReceipts(stage, fence, admissions) {
-    const counts = new Map();
-    for (const admission of admissions) {
-        for (const tellId of admission.tellIds)
-            counts.set(tellId, (counts.get(tellId) ?? 0) + 1);
-    }
-    if ([...counts.values()].some((count) => count !== 1))
-        return [];
-    return [...counts.keys()].sort().map((tellId) => ({
-        stage,
-        correlation: { kind: "exact", tellId },
-        launchInput: { fence },
-    }));
-}

package/build/agents/harness/event-channel.js

@@ -1,213 +0,0 @@
-/** Closed hard cap for adapter event buffers (§1.5 / faye #315). Not configurable. */
-export const EXEC_EVENT_BUFFER_HARD_CAP = 10_000;
-export function createEventChannelOverflowError(message) {
-    const error = new Error(message ??
-        `Agent event buffer reached hard cap ${EXEC_EVENT_BUFFER_HARD_CAP}; aborting stream (PROJECTION_STATE_ERROR).`);
-    error.name = "EventChannelOverflowError";
-    error.code = "PROJECTION_STATE_ERROR";
-    return error;
-}
-export function isEventChannelOverflowError(error) {
-    return (error instanceof Error &&
-        error.code === "PROJECTION_STATE_ERROR" &&
-        error.name === "EventChannelOverflowError");
-}
-/**
- * Bounded async event channel for adapter -> runtime.
- * Hard cap is exactly 10_000 (shared across lifecycle + coalesce slots).
- * Consumer-lag overflow saturates observation without failing the producer or consumer.
- */
-export function createEventChannel(options = {}) {
-    const queue = [];
-    /** Index of the live entry for each coalesce key. */
-    const coalesceIndex = new Map();
-    const waiters = [];
-    let closed = false;
-    let failure;
-    let overflowed = false;
-    let overflowMarker;
-    let overflowMarkerPending = false;
-    let drained = false;
-    let resolveDrained;
-    const drainedPromise = new Promise((resolve) => {
-        resolveDrained = resolve;
-    });
-    const markDrained = () => {
-        if (drained)
-            return;
-        drained = true;
-        resolveDrained();
-    };
-    const reindexCoalesceKeys = () => {
-        coalesceIndex.clear();
-        for (let i = 0; i < queue.length; i += 1) {
-            const key = queue[i].coalesceKey;
-            if (key !== undefined) {
-                coalesceIndex.set(key, i);
-            }
-        }
-    };
-    /**
-     * Deliver terminal signal only to currently parked consumers.
-     * Does NOT mark drained when there are no waiters: a zero-event close/error must
-     * leave whenDrained pending until a consumer actually pulls terminal done/reject.
-     */
-    const deliverTerminalToWaiters = () => {
-        if (waiters.length === 0)
-            return;
-        while (waiters.length > 0) {
-            const waiter = waiters.shift();
-            if (failure !== undefined) {
-                markDrained();
-                waiter.reject(failure);
-            }
-            else {
-                markDrained();
-                waiter.resolve({ value: undefined, done: true });
-            }
-        }
-    };
-    const depth = () => queue.length;
-    const storeOverflowMarker = (dropped) => {
-        if (overflowMarkerPending)
-            return;
-        const marker = options.createOverflowMarker ? options.createOverflowMarker(dropped) : dropped;
-        overflowMarker = marker;
-        overflowMarkerPending = true;
-    };
-    const takeOverflowMarker = () => {
-        if (!overflowMarkerPending || overflowMarker === undefined)
-            return undefined;
-        const marker = overflowMarker;
-        overflowMarker = undefined;
-        overflowMarkerPending = false;
-        return marker;
-    };
-    const markOverflow = (dropped) => {
-        overflowed = true;
-        storeOverflowMarker(dropped);
-        const waiter = waiters.shift();
-        if (waiter && queue.length === 0) {
-            const marker = takeOverflowMarker();
-            if (marker !== undefined) {
-                waiter.resolve({ value: marker, done: false });
-            }
-            else if (closed) {
-                markDrained();
-                if (failure !== undefined)
-                    waiter.reject(failure);
-                else
-                    waiter.resolve({ value: undefined, done: true });
-            }
-            else {
-                waiters.unshift(waiter);
-            }
-        }
-        return "overflow";
-    };
-    return {
-        push(value, meta) {
-            if (closed)
-                return "closed";
-            if (overflowed)
-                return "overflow";
-            const coalesceKey = meta?.coalesceKey;
-            if (coalesceKey !== undefined) {
-                const existing = coalesceIndex.get(coalesceKey);
-                if (existing !== undefined) {
-                    // Same-key replacement: newest snapshot wins; depth unchanged.
-                    queue[existing] = { value, coalesceKey };
-                    return "accepted";
-                }
-                if (depth() >= EXEC_EVENT_BUFFER_HARD_CAP) {
-                    return markOverflow(value);
-                }
-                const waiter = waiters.shift();
-                if (waiter) {
-                    waiter.resolve({ value, done: false });
-                    return "accepted";
-                }
-                coalesceIndex.set(coalesceKey, queue.length);
-                queue.push({ value, coalesceKey });
-                return "accepted";
-            }
-            // Lifecycle: never coalesce.
-            if (depth() >= EXEC_EVENT_BUFFER_HARD_CAP) {
-                return markOverflow(value);
-            }
-            const waiter = waiters.shift();
-            if (waiter) {
-                waiter.resolve({ value, done: false });
-                return "accepted";
-            }
-            queue.push({ value });
-            return "accepted";
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            if (queue.length === 0 && !overflowMarkerPending) {
-                deliverTerminalToWaiters();
-            }
-        },
-        error(error) {
-            if (closed && failure !== undefined)
-                return;
-            closed = true;
-            failure = error;
-            if (queue.length === 0 && !overflowMarkerPending) {
-                deliverTerminalToWaiters();
-            }
-        },
-        whenDrained() {
-            return drainedPromise;
-        },
-        depth,
-        peekCoalesced(coalesceKey) {
-            const index = coalesceIndex.get(coalesceKey);
-            if (index === undefined)
-                return undefined;
-            return queue[index]?.value;
-        },
-        iterable: {
-            [Symbol.asyncIterator]() {
-                return {
-                    next() {
-                        if (queue.length > 0) {
-                            const entry = queue.shift();
-                            reindexCoalesceKeys();
-                            return Promise.resolve({ value: entry.value, done: false });
-                        }
-                        const marker = takeOverflowMarker();
-                        if (marker !== undefined) {
-                            return Promise.resolve({ value: marker, done: false });
-                        }
-                        if (failure !== undefined) {
-                            markDrained();
-                            return Promise.reject(failure);
-                        }
-                        if (closed) {
-                            markDrained();
-                            return Promise.resolve({ value: undefined, done: true });
-                        }
-                        return new Promise((resolve, reject) => {
-                            waiters.push({
-                                resolve: (result) => {
-                                    if (result.done) {
-                                        markDrained();
-                                    }
-                                    resolve(result);
-                                },
-                                reject: (error) => {
-                                    markDrained();
-                                    reject(error);
-                                },
-                            });
-                        });
-                    },
-                };
-            },
-        },
-    };
-}

package/build/agents/harness/event-persistence.js

@@ -1,220 +0,0 @@
-import { AGENT_ACTIVITY_MAX_CHANGES, AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
-import { EXEC_EVENT_BUFFER_HARD_CAP } from "./event-channel.js";
-export function createTruncationMarker(envelope = {
-    seq: EXEC_EVENT_BUFFER_HARD_CAP,
-    at: new Date().toISOString(),
-    turn: 0,
-}) {
-    return {
-        type: "truncation",
-        limit: EXEC_EVENT_BUFFER_HARD_CAP,
-        admitted: EXEC_EVENT_BUFFER_HARD_CAP,
-        seq: envelope.seq,
-        at: envelope.at,
-        turn: envelope.turn,
-    };
-}
-export function overflowMarkerFromDropped(dropped) {
-    if (dropped.type === "truncation")
-        return dropped;
-    return createTruncationMarker({
-        seq: dropped.seq,
-        at: dropped.at,
-        turn: dropped.turn,
-    });
-}
-function truncateText(value, limit = AGENT_EVENT_TEXT_MAX_CHARS) {
-    return {
-        value: value.slice(0, limit),
-        truncated: value.length > limit,
-    };
-}
-/** Bound unknown native payloads before they enter the projection event stream. */
-export function serializeUnknownPayload(value) {
-    let serialized;
-    try {
-        const encoded = JSON.stringify(value);
-        if (encoded === undefined) {
-            return {
-                payload: "null",
-                elided: { reason: "unserializable", retainedChars: 4 },
-            };
-        }
-        serialized = encoded;
-    }
-    catch {
-        serialized = "null";
-        return {
-            payload: serialized,
-            elided: { reason: "unserializable", retainedChars: serialized.length },
-        };
-    }
-    if (serialized.length <= AGENT_UNKNOWN_PAYLOAD_MAX_CHARS)
-        return { payload: serialized };
-    return {
-        payload: serialized.slice(0, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS),
-        elided: {
-            reason: "truncated",
-            originalChars: serialized.length,
-            retainedChars: AGENT_UNKNOWN_PAYLOAD_MAX_CHARS,
-        },
-    };
-}
-function normalizeBodyForPersistence(body) {
-    switch (body.type) {
-        case "message": {
-            const id = truncateText(body.id);
-            const text = truncateText(body.text);
-            return {
-                body: { ...body, id: id.value, text: text.value },
-                truncated: id.truncated || text.truncated,
-            };
-        }
-        case "unknown": {
-            const provider = truncateText(body.provider);
-            const nativeType = truncateText(body.nativeType);
-            const payload = truncateText(body.payload);
-            return {
-                body: {
-                    ...body,
-                    provider: provider.value,
-                    nativeType: nativeType.value,
-                    payload: payload.value,
-                    ...(payload.truncated && body.elided === undefined
-                        ? { elided: { reason: "truncated", originalChars: body.payload.length, retainedChars: payload.value.length } }
-                        : {}),
-                },
-                truncated: provider.truncated || nativeType.truncated || payload.truncated,
-            };
-        }
-        case "activity": {
-            const id = truncateText(body.id);
-            const tool = truncateText(body.tool);
-            let truncated = id.truncated || tool.truncated;
-            const text = (value) => {
-                const bounded = truncateText(value);
-                truncated ||= bounded.truncated;
-                return bounded.value;
-            };
-            const call = (() => {
-                switch (body.call.kind) {
-                    case "run":
-                        return {
-                            ...body.call,
-                            command: text(body.call.command),
-                            ...(body.call.description === undefined ? {} : { description: text(body.call.description) }),
-                        };
-                    case "read":
-                        return { ...body.call, path: text(body.call.path) };
-                    case "search":
-                        return { ...body.call, query: text(body.call.query) };
-                    case "fileChange": {
-                        const kept = body.call.changes.slice(0, AGENT_ACTIVITY_MAX_CHANGES);
-                        const dropped = body.call.changes.length - kept.length;
-                        truncated ||= dropped > 0;
-                        return {
-                            ...body.call,
-                            changes: kept.map((change) => ({ ...change, path: text(change.path) })),
-                            ...((body.call.omittedChanges ?? 0) + dropped > 0
-                                ? { omittedChanges: (body.call.omittedChanges ?? 0) + dropped }
-                                : {}),
-                        };
-                    }
-                    case "other":
-                        return { ...body.call, display: text(body.call.display) };
-                }
-            })();
-            const result = body.result === undefined
-                ? undefined
-                : {
-                    ...body.result,
-                    ...(body.result.message === undefined ? {} : { message: text(body.result.message) }),
-                };
-            return {
-                body: {
-                    ...body,
-                    id: id.value,
-                    tool: tool.value,
-                    call,
-                    ...(result === undefined ? {} : { result }),
-                    ...(truncated ? { truncated: true } : {}),
-                },
-                truncated,
-            };
-        }
-        case "thought":
-        case "plan":
-        case "truncation":
-        case "turn":
-            return { body, truncated: false };
-        case "usage": {
-            const model = body.model === undefined ? undefined : truncateText(body.model);
-            return {
-                body: { ...body, ...(model ? { model: model.value } : {}) },
-                truncated: model?.truncated ?? false,
-            };
-        }
-        case "warning": {
-            if (body.warning.reason === "retry" || body.warning.reason === "rate-limit") {
-                return { body, truncated: false };
-            }
-            const originalModel = body.warning.originalModel === undefined ? undefined : truncateText(body.warning.originalModel);
-            const fallbackModel = body.warning.fallbackModel === undefined ? undefined : truncateText(body.warning.fallbackModel);
-            const direction = body.warning.direction === undefined ? undefined : truncateText(body.warning.direction);
-            const requestId = body.warning.requestId === undefined || body.warning.requestId === null
-                ? undefined
-                : truncateText(body.warning.requestId);
-            const signerModel = body.warning.signerModel === undefined ? undefined : truncateText(body.warning.signerModel);
-            return {
-                body: {
-                    ...body,
-                    warning: {
-                        ...body.warning,
-                        ...(originalModel ? { originalModel: originalModel.value } : {}),
-                        ...(fallbackModel ? { fallbackModel: fallbackModel.value } : {}),
-                        ...(direction ? { direction: direction.value } : {}),
-                        ...(requestId ? { requestId: requestId.value } : {}),
-                        ...(signerModel ? { signerModel: signerModel.value } : {}),
-                    },
-                },
-                truncated: [originalModel, fallbackModel, direction, requestId, signerModel]
-                    .some((entry) => entry?.truncated === true),
-            };
-        }
-        case "diagnostic": {
-            const text = truncateText(body.text);
-            return { body: { ...body, text: text.value }, truncated: text.truncated };
-        }
-        case "done": {
-            const finalMessage = body.finalMessage === undefined
-                ? undefined
-                : truncateText(body.finalMessage, AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS);
-            return {
-                body: { ...body, ...(finalMessage ? { finalMessage: finalMessage.value } : {}) },
-                truncated: finalMessage?.truncated ?? false,
-            };
-        }
-        case "fail": {
-            const message = truncateText(body.message);
-            const diagnostics = body.diagnostics === undefined ? undefined : truncateText(body.diagnostics);
-            return {
-                body: {
-                    ...body,
-                    message: message.value,
-                    ...(diagnostics ? { diagnostics: diagnostics.value } : {}),
-                },
-                truncated: message.truncated || (diagnostics?.truncated ?? false),
-            };
-        }
-    }
-}
-export function prepareAgentEventForPersistence(event) {
-    const normalized = normalizeBodyForPersistence(event);
-    return {
-        ...normalized.body,
-        seq: event.seq,
-        at: event.at,
-        turn: event.turn,
-        ...(normalized.truncated ? { truncated: true } : {}),
-    };
-}

package/build/agents/harness/events.js

@@ -1,48 +0,0 @@
-import { z } from "zod";
-export const AGENT_EVENT_TEXT_MAX_CHARS = 16_384;
-export const AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS = 65_536;
-export const AGENT_THOUGHT_TEXT_MAX_CHARS = 4_000;
-export const AGENT_PLAN_MAX_ITEMS = 64;
-export const AGENT_PLAN_ITEM_TEXT_MAX_CHARS = 200;
-export const AGENT_ACTIVITY_MAX_CHANGES = 32;
-export const AGENT_UNKNOWN_PAYLOAD_MAX_CHARS = AGENT_EVENT_TEXT_MAX_CHARS;
-export const activityCallSchema = z.discriminatedUnion("kind", [
-    z.object({ kind: z.literal("run"), command: z.string(), description: z.string().optional() }).strict(),
-    z.object({
-        kind: z.literal("read"),
-        path: z.string(),
-        range: z.object({ offset: z.number().finite().optional(), limit: z.number().finite().optional() }).strict().optional(),
-    }).strict(),
-    z.object({ kind: z.literal("search"), query: z.string() }).strict(),
-    z.object({
-        kind: z.literal("fileChange"),
-        changes: z.array(z.object({ op: z.enum(["add", "update", "delete"]), path: z.string() }).strict()),
-        omittedChanges: z.number().int().nonnegative().optional(),
-    }).strict(),
-    z.object({ kind: z.literal("other"), display: z.string() }).strict(),
-]);
-export const activityResultSchema = z.object({
-    status: z.enum(["ok", "error"]),
-    message: z.string().optional(),
-    exitCode: z.number().finite().optional(),
-    diffstat: z.object({
-        additions: z.number().int().nonnegative(),
-        deletions: z.number().int().nonnegative(),
-    }).strict().optional(),
-}).strict();
-export const activityEventBodySchema = z.object({
-    type: z.literal("activity"),
-    phase: z.enum(["started", "updated", "completed"]),
-    id: z.string(),
-    tool: z.string(),
-    call: activityCallSchema,
-    result: activityResultSchema.optional(),
-    truncated: z.literal(true).optional(),
-}).strict().superRefine((value, context) => {
-    if (value.phase === "started" && value.result !== undefined) {
-        context.addIssue({ code: "custom", path: ["result"], message: "started activity cannot carry a result" });
-    }
-    if (value.phase === "completed" && value.result === undefined) {
-        context.addIssue({ code: "custom", path: ["result"], message: "completed activity requires a result" });
-    }
-});