@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/agents/effective-policy.js

@@ -0,0 +1,32 @@
+import { FlowError } from "../flow-error.js";
+function deepOverlay(base, extra) {
+    const next = {};
+    for (const key of Object.keys(base))
+        Object.defineProperty(next, key, { value: base[key], enumerable: true, configurable: true, writable: true });
+    for (const key of Object.keys(extra)) {
+        const value = extra[key];
+        const prior = Object.prototype.hasOwnProperty.call(next, key) ? next[key] : undefined;
+        const merged = value && typeof value === "object" && !Array.isArray(value)
+            ? prior && typeof prior === "object" && !Array.isArray(prior)
+                ? deepOverlay(prior, value)
+                : deepOverlay({}, value)
+            : value;
+        Object.defineProperty(next, key, { value: merged, enumerable: true, configurable: true, writable: true });
+    }
+    return next;
+}
+export function resolveEffectiveCodexSdkProfile(profile, cwd, overrides = {}) {
+    if (profile.webSearchPolicy === "cached" || profile.webSearchPolicy === "live")
+        throw new FlowError("UNSUPPORTED_POLICY", `Codex SDK unified webSearchPolicy '${profile.webSearchPolicy}' is unsupported because native web-search capability was not proven with either networkAccessEnabled=false or networkAccessEnabled=true; this restriction can be lifted only by future real native tool-provisioning evidence.`);
+    const unified = {
+        sandboxMode: profile.accessPolicy === "read" ? "read-only" : "workspace-write",
+        networkAccessEnabled: profile.networkPolicy === "enabled",
+        webSearchMode: profile.webSearchPolicy ?? "disabled",
+        ...(profile.model ? { model: profile.model } : {}),
+        ...(profile.effort ? { modelReasoningEffort: profile.effort === "max" ? "xhigh" : profile.effort } : {}),
+    };
+    const native = deepOverlay(unified, profile.threadOptions ?? {});
+    const threadOptions = { ...native, ...(overrides.model ? { model: overrides.model } : {}), ...(overrides.effort ? { modelReasoningEffort: overrides.effort === "max" ? "xhigh" : overrides.effort } : {}), workingDirectory: cwd, skipGitRepoCheck: true };
+    const policy = { ...(threadOptions.sandboxMode === "read-only" ? { accessPolicy: "read" } : threadOptions.sandboxMode === "workspace-write" || threadOptions.sandboxMode === "danger-full-access" ? { accessPolicy: "write" } : {}), ...(typeof threadOptions.networkAccessEnabled === "boolean" ? { networkPolicy: threadOptions.networkAccessEnabled ? "enabled" : "disabled" } : {}), ...(threadOptions.webSearchMode === "disabled" || threadOptions.webSearchMode === "cached" || threadOptions.webSearchMode === "live" ? { webSearchPolicy: threadOptions.webSearchMode } : {}) };
+    return Object.freeze({ provider: "codex-sdk", executable: profile.executable, ...(profile.profile ? { profile: profile.profile } : {}), ...(profile.config ? { config: profile.config } : {}), ...(typeof threadOptions.model === "string" ? { model: threadOptions.model } : {}), threadOptions: Object.freeze(threadOptions), effectivePolicy: Object.freeze(policy) });
+}

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

@@ -0,0 +1,178 @@
+/** 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).
+ * Channel is blind to provider raw shapes; coalesce keys are explicit opaque strings.
+ */
+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 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) {
+                // Rejection path marks drained in the waiter reject wrapper below when next() parks;
+                // for direct delivery, mark here after reject so whenDrained observes consumer receipt.
+                markDrained();
+                waiter.reject(failure);
+            }
+            else {
+                markDrained();
+                waiter.resolve({ value: undefined, done: true });
+            }
+        }
+    };
+    const depth = () => queue.length;
+    const markOverflow = () => {
+        const error = createEventChannelOverflowError();
+        failure = error;
+        closed = true;
+        options.onOverflow?.(error);
+        if (queue.length === 0) {
+            deliverTerminalToWaiters();
+        }
+        return "overflow";
+    };
+    return {
+        push(value, meta) {
+            if (closed)
+                return "closed";
+            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();
+                }
+                const waiter = waiters.shift();
+                if (waiter) {
+                    // Direct delivery to a waiting consumer: nothing remains queued for this key.
+                    waiter.resolve({ value, done: false });
+                    return "accepted";
+                }
+                coalesceIndex.set(coalesceKey, queue.length);
+                queue.push({ value, coalesceKey });
+                return "accepted";
+            }
+            // Lifecycle: never coalesce or drop.
+            if (depth() >= EXEC_EVENT_BUFFER_HARD_CAP) {
+                return markOverflow();
+            }
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter.resolve({ value, done: false });
+                return "accepted";
+            }
+            queue.push({ value });
+            return "accepted";
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            // Empty queue + no waiter: leave whenDrained pending until consumer pulls done.
+            if (queue.length === 0) {
+                deliverTerminalToWaiters();
+            }
+        },
+        error(error) {
+            if (closed && failure !== undefined)
+                return;
+            closed = true;
+            failure = error;
+            // Empty queue + no waiter: leave whenDrained pending until consumer pulls rejection.
+            if (queue.length === 0) {
+                deliverTerminalToWaiters();
+            }
+        },
+        whenDrained() {
+            return drainedPromise;
+        },
+        depth,
+        iterable: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() {
+                        if (queue.length > 0) {
+                            const entry = queue.shift();
+                            reindexCoalesceKeys();
+                            // After the last item leaves under a closed/failed producer, the next next()
+                            // (or a parked waiter) must still receive the terminal signal.
+                            return Promise.resolve({ value: entry.value, 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/execution-handle.js

@@ -0,0 +1,117 @@
+import { randomUUID } from "node:crypto";
+import { createEventChannel, createEventChannelOverflowError, isEventChannelOverflowError, } from "./event-channel.js";
+import { SubagentFailure } from "../types.js";
+export function createOverflowFailStream(channel) {
+    let drained = false;
+    let resolveDrained;
+    const drainedPromise = new Promise((resolve) => {
+        resolveDrained = resolve;
+    });
+    const markDrained = () => {
+        if (drained)
+            return;
+        drained = true;
+        resolveDrained();
+    };
+    return {
+        events: {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    for await (const event of channel.iterable) {
+                        yield event;
+                    }
+                }
+                catch (error) {
+                    if (!isEventChannelOverflowError(error)) {
+                        throw error;
+                    }
+                    yield {
+                        type: "fail",
+                        code: "PROJECTION_STATE_ERROR",
+                        message: error.message,
+                    };
+                }
+                finally {
+                    markDrained();
+                }
+            },
+        },
+        whenDrained: () => drainedPromise,
+    };
+}
+export function createProjectionDriver(input) {
+    const id = input.id ?? randomUUID();
+    const abortController = new AbortController();
+    let finishStarted = false;
+    let overflowed = false;
+    let resolveCompletion;
+    let rejectCompletion;
+    const completion = new Promise((resolve, reject) => {
+        resolveCompletion = resolve;
+        rejectCompletion = reject;
+    });
+    completion.catch(() => undefined);
+    const channel = createEventChannel({
+        onOverflow: () => {
+            overflowed = true;
+            if (!abortController.signal.aborted) {
+                abortController.abort();
+            }
+            void input.abort?.();
+        },
+    });
+    const eventStream = createOverflowFailStream(channel);
+    const finish = (action) => {
+        if (finishStarted)
+            return;
+        finishStarted = true;
+        channel.close();
+        void eventStream.whenDrained().then(action, action);
+    };
+    const overflowFailure = () => new SubagentFailure("SUBAGENT_EXEC_ERROR", createEventChannelOverflowError().message, {
+        diagnostics: "PROJECTION_STATE_ERROR",
+    });
+    const runPromise = (async () => {
+        try {
+            const outcome = await input.run({
+                emit(event, meta) {
+                    channel.push(event, meta);
+                },
+                signal: abortController.signal,
+            });
+            if (overflowed) {
+                finish(() => rejectCompletion(overflowFailure()));
+                return;
+            }
+            finish(() => resolveCompletion(outcome));
+        }
+        catch (error) {
+            if (overflowed || isEventChannelOverflowError(error)) {
+                finish(() => rejectCompletion(error instanceof SubagentFailure && error.diagnostics === "PROJECTION_STATE_ERROR"
+                    ? error
+                    : overflowFailure()));
+                return;
+            }
+            finish(() => rejectCompletion(error));
+        }
+    })();
+    void runPromise;
+    const enqueue = input.enqueue &&
+        (async (message) => {
+            return input.enqueue(message);
+        });
+    return {
+        id,
+        events: eventStream.events,
+        completion,
+        steerMode: input.steerMode,
+        ...(enqueue ? { enqueue } : {}),
+        ...(input.clearQueue ? { clearQueue: input.clearQueue } : {}),
+        async abort() {
+            if (!abortController.signal.aborted) {
+                abortController.abort();
+            }
+            await input.abort?.();
+        },
+    };
+}