@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -5,7 +5,8 @@ import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : undefined;
+        ? value
+        : undefined;
 }
 function text(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
@@ -135,10 +136,7 @@ function nativeProgress(type, properties, busy) {
 function startsTurn(value, sessionId, messageID) {
     const event = object(value);
     const info = object(object(event?.properties)?.info);
-    return event?.type === "message.updated"
-        && info?.sessionID === sessionId
-        && info.role === "user"
-        && info.id === messageID;
+    return (event?.type === "message.updated" && info?.sessionID === sessionId && info.role === "user" && info.id === messageID);
 }
 async function observeTurn(input) {
     let active = false;
@@ -206,9 +204,7 @@ async function forceDisposeOpencode(abortController, close, finish) {
 async function drive(execution, input, loader) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
-    const resumeSessionId = input.session.kind === "resume"
-        ? opencodeSessionId(input.session.coordinate)
-        : undefined;
+    const resumeSessionId = input.session.kind === "resume" ? opencodeSessionId(input.session.coordinate) : undefined;
     const abortController = new AbortController();
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
@@ -240,11 +236,20 @@ async function drive(execution, input, loader) {
         const messageID = `msg_${randomUUID().replaceAll("-", "")}`;
         const submissionState = { started: false };
         events.emit({ type: "session", coordinate: coordinate(sessionId) });
-        const streamResult = await abortable(runtime.client.event.subscribe({ query: { directory: input.cwd } }), abortController.signal, async (late) => { await late.stream[Symbol.asyncIterator]().return?.(undefined); });
+        const streamResult = await abortable(runtime.client.event.subscribe({ query: { directory: input.cwd } }), abortController.signal, async (late) => {
+            await late.stream[Symbol.asyncIterator]().return?.(undefined);
+        });
         iterator = streamResult.stream[Symbol.asyncIterator]();
         const { completion, finish } = terminalSettlement(events, closeOnce);
         const observation = observeTurn({
-            iterator, session, sessionId, cwd: input.cwd, messageID, events, state, submissionState,
+            iterator,
+            session,
+            sessionId,
+            cwd: input.cwd,
+            messageID,
+            events,
+            state,
+            submissionState,
         });
         submissionState.started = true;
         await abortable(session.promptAsync({
@@ -261,7 +266,9 @@ async function drive(execution, input, loader) {
             completion,
             abort: async () => {
                 abortController.abort();
-                void session.abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true }).catch(() => undefined);
+                void session
+                    .abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true })
+                    .catch(() => undefined);
                 await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
             },
             forceDispose: () => forceDisposeOpencode(abortController, closeOnce, finish),
@@ -288,12 +295,14 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
             return {
                 kind: "admitted",
                 options: Object.freeze({ ...options }),
-                ...(options.readonly === undefined ? {} : {
-                    readonly: {
-                        enforcement: "none",
-                        diagnostic: "OpenCode V1 cannot remove task-surface mutation capabilities",
-                    },
-                }),
+                ...(options.readonly === undefined
+                    ? {}
+                    : {
+                        readonly: {
+                            enforcement: "none",
+                            diagnostic: "OpenCode V1 cannot remove task-surface mutation capabilities",
+                        },
+                    }),
             };
         },
         start: (input) => drive(execution, input, loader),

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -33,20 +33,29 @@ async function availablePort() {
                 reject(new Error("OpenCode port unavailable"));
                 return;
             }
-            server.close((error) => error === undefined ? resolve(address.port) : reject(error));
+            server.close((error) => (error === undefined ? resolve(address.port) : reject(error)));
         });
     });
 }
 export async function loadOpencode(execution, cwd, signal, loader) {
     if (loader) {
         const loaded = await loader(cwd, execution);
-        return { client: loaded.client, close: async () => { await loaded.close?.(); } };
+        return {
+            client: loaded.client,
+            close: async () => {
+                await loaded.close?.();
+            },
+        };
     }
     const port = await availablePort();
     const owned = await spawnDetachedProcess({
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
-        env: { ...process.env, ...execution.env },
+        env: {
+            ...process.env,
+            ...(execution.config === undefined ? {} : { OPENCODE_CONFIG_CONTENT: JSON.stringify(execution.config) }),
+            ...execution.env,
+        },
         log: `${cwd}/.opencode.log`,
     });
     const { createOpencodeClient } = await import("@opencode-ai/sdk");
@@ -58,6 +67,13 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         await owned.terminate();
         throw error;
     }
-    return { client, close: async () => { await owned.terminate(); } };
+    return {
+        client,
+        close: async () => {
+            await owned.terminate();
+        },
+    };
+}
+export function coordinate(sessionId) {
+    return { sessionId };
 }
-export function coordinate(sessionId) { return { sessionId }; }

package/build/src/akuma/providers/pi/events.js

@@ -23,25 +23,29 @@ export const PI_EVENT_DISPOSITIONS = {
 };
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : null;
+        ? value
+        : null;
 }
 function textContent(content) {
     if (typeof content === "string")
         return content;
     if (!Array.isArray(content))
         return "";
-    return content.map((block) => {
+    return content
+        .map((block) => {
         const value = record(block);
         return value?.type === "text" && typeof value.text === "string" ? value.text : "";
-    }).join("");
+    })
+        .join("");
 }
 function hasTextContent(content) {
     if (typeof content === "string")
         return true;
-    return Array.isArray(content) && content.some((block) => {
-        const value = record(block);
-        return value?.type === "text" && typeof value.text === "string";
-    });
+    return (Array.isArray(content) &&
+        content.some((block) => {
+            const value = record(block);
+            return value?.type === "text" && typeof value.text === "string";
+        }));
 }
 function positiveLine(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
@@ -50,9 +54,7 @@ function optionalText(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 function runCall(name, value) {
-    return name === "bash" && typeof value.command === "string"
-        ? { kind: "run", command: value.command }
-        : undefined;
+    return name === "bash" && typeof value.command === "string" ? { kind: "run", command: value.command } : undefined;
 }
 function readCall(name, value) {
     if (name !== "read" || typeof value.path !== "string")
@@ -101,11 +103,10 @@ function refineEditCall(call, result) {
 }
 function toolCall(name, args) {
     const value = record(args) ?? {};
-    return runCall(name, value)
-        ?? readCall(name, value)
-        ?? searchCall(name, value)
-        ?? fileChangeCall(name, value)
-        ?? { kind: "other", display: name };
+    return (runCall(name, value) ??
+        readCall(name, value) ??
+        searchCall(name, value) ??
+        fileChangeCall(name, value) ?? { kind: "other", display: name });
 }
 function translateNote(event) {
     if (event.type === "auto_retry_start")
@@ -122,11 +123,16 @@ function translateToolEnd(event, state) {
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
     const call = started?.call ?? { kind: "other", display: name };
-    return [{
-            type: "tool", phase: "completed", id: event.toolCallId, name,
+    return [
+        {
+            type: "tool",
+            phase: "completed",
+            id: event.toolCallId,
+            name,
             call: event.isError ? call : refineEditCall(call, event.result),
             result: { status: event.isError ? "error" : "ok" },
-        }];
+        },
+    ];
 }
 function translateMessage(event, state) {
     const message = record(event.message);
@@ -174,7 +180,8 @@ export function piTerminalFailure(messages) {
         if (message.stopReason !== "error")
             return null;
         return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
-            ? message.errorMessage : "Pi provider ended with an error";
+            ? message.errorMessage
+            : "Pi provider ended with an error";
     }
     return null;
 }

package/build/src/akuma/providers/pi/index.js

@@ -3,7 +3,9 @@ import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
-function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function admitPiOptions(options) {
     if (options.network !== undefined)
         return { kind: "refused", diagnostic: "Pi provider does not support the network option" };
@@ -29,27 +31,33 @@ async function piCreateOptions(sdk, input) {
         if (model === undefined)
             throw new Error(`Pi model '${input.options.model}' is unavailable`);
     }
-    const resourceLoader = input.options.systemPrompt === undefined ? undefined : new sdk.DefaultResourceLoader({
-        cwd: input.cwd,
-        agentDir: sdk.getAgentDir(),
-        ...(input.options.systemPromptMode === "append"
-            ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
-            : { systemPromptOverride: () => input.options.systemPrompt }),
-    });
+    const resourceLoader = input.options.systemPrompt === undefined
+        ? undefined
+        : new sdk.DefaultResourceLoader({
+            cwd: input.cwd,
+            agentDir: sdk.getAgentDir(),
+            ...(input.options.systemPromptMode === "append"
+                ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
+                : { systemPromptOverride: () => input.options.systemPrompt }),
+        });
     await resourceLoader?.reload();
     const sessionManager = input.session.kind === "fresh"
         ? sdk.SessionManager.create(input.cwd)
         : "sessionFile" in input.session.coordinate
             ? sdk.SessionManager.open(input.session.coordinate.sessionFile)
-            : (() => { throw new Error("Pi resume requires sessionFile"); })();
+            : (() => {
+                throw new Error("Pi resume requires sessionFile");
+            })();
     const customTools = input.requests === undefined || input.options.readonly === true
         ? undefined
-        : [(await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
+        : [
+            (await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
                 spawnHook: (context) => ({
                     ...context,
                     env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
                 }),
-            })];
+            }),
+        ];
     return {
         cwd: input.cwd,
         sessionManager,
@@ -60,8 +68,13 @@ async function piCreateOptions(sdk, input) {
         ...(customTools === undefined ? {} : { customTools }),
     };
 }
-async function createPiSession(sdk, input, signal) {
-    const setup = piCreateOptions(sdk, input).then(async (options) => await sdk.createAgentSession(options));
+async function createPiSession(sdk, execution, input, signal) {
+    const setup = piCreateOptions(sdk, input).then(async (options) => {
+        if (execution.config !== undefined) {
+            throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
+        }
+        return await sdk.createAgentSession(options);
+    });
     return await abortable(setup, signal, (created) => created.session.dispose());
 }
 function forceDisposePi(dispose, settle, setAborting) {
@@ -70,8 +83,8 @@ function forceDisposePi(dispose, settle, setAborting) {
     settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     return Promise.resolve();
 }
-async function drivePi(sdk, input, signal) {
-    const created = await createPiSession(sdk, input, signal);
+async function drivePi(sdk, execution, input, signal) {
+    const created = await createPiSession(sdk, execution, input, signal);
     const native = created.session;
     if (signal.aborted) {
         native.dispose();
@@ -112,7 +125,9 @@ async function drivePi(sdk, input, signal) {
     });
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
     let settleCompletion;
-    const completion = new Promise((resolve) => { settleCompletion = resolve; });
+    const completion = new Promise((resolve) => {
+        settleCompletion = resolve;
+    });
     const settle = (result) => {
         if (settled)
             return;
@@ -123,24 +138,22 @@ async function drivePi(sdk, input, signal) {
     void (async () => {
         try {
             await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
-            if (aborting) {
-                settle({ kind: "failed", diagnostic: "Pi session aborted" });
-                return;
-            }
-            if (terminalFailure !== null) {
-                settle({ kind: "failed", diagnostic: terminalFailure });
-                return;
+            let result;
+            if (aborting)
+                result = { kind: "failed", diagnostic: "Pi session aborted" };
+            else if (terminalFailure !== null)
+                result = { kind: "failed", diagnostic: terminalFailure };
+            else if (!state.assistantSeen)
+                result = { kind: "failed", diagnostic: "Pi completed without a native assistant answer" };
+            else {
+                const historyId = native.sessionManager.getLeafId();
+                result = {
+                    kind: "answered",
+                    answer: state.answer,
+                    ...(historyId === null ? {} : { historyId }),
+                };
             }
-            if (!state.assistantSeen) {
-                settle({ kind: "failed", diagnostic: "Pi completed without a native assistant answer" });
-                return;
-            }
-            const historyId = native.sessionManager.getLeafId();
-            settle({
-                kind: "answered",
-                answer: state.answer,
-                ...(historyId === null ? {} : { historyId }),
-            });
+            settle(result);
         }
         catch (error) {
             settle(aborting
@@ -149,7 +162,9 @@ async function drivePi(sdk, input, signal) {
         }
     })();
     return {
-        admission: { fence: native.sessionId }, events, completion,
+        admission: { fence: native.sessionId },
+        events,
+        completion,
         abort: () => {
             abortRequest ??= (async () => {
                 if (settled)
@@ -158,12 +173,16 @@ async function drivePi(sdk, input, signal) {
                 try {
                     await native.abort();
                 }
-                catch { /* prompt settlement still proves local cleanup */ }
+                catch {
+                    /* prompt settlement still proves local cleanup */
+                }
                 settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
             return abortRequest;
         },
-        forceDispose: () => forceDisposePi(dispose, settle, () => { aborting = true; }),
+        forceDispose: () => forceDisposePi(dispose, settle, () => {
+            aborting = true;
+        }),
     };
 }
 function piSessionFile(coordinate) {
@@ -190,16 +209,15 @@ async function loadPiSdk() {
     };
 }
 export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = loadPiSdk) {
-    if (execution.executable !== undefined || execution.config !== undefined) {
-        throw new TypeError("Pi provider does not support executable or config");
-    }
+    if (execution.executable !== undefined)
+        throw new TypeError("Pi provider does not support executable");
     if (execution.env !== undefined && Object.keys(execution.env).length > 0) {
         throw new TypeError("env injection not supported for provider pi");
     }
     const drive = async (input) => {
         const signal = input.signal ?? new AbortController().signal;
         signal.throwIfAborted();
-        return drivePi(await abortable(load(), signal), input, signal);
+        return drivePi(await abortable(load(), signal), execution, input, signal);
     };
     return {
         admitOptions: admitPiOptions,

package/build/src/akuma/publication.js

@@ -1,7 +1,7 @@
-import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul, } from "./heart/index.js";
-import { allocateAkumaDirectory, } from "./identity.js";
+import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul } from "./heart/index.js";
+import { allocateAkumaDirectory } from "./identity.js";
 import { abortableDelay } from "./abort.js";
-const POLL_MS = 25;
+const POLL_MS = 100;
 export const BIRTH_TIMEOUT_MS = 30_000;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -22,9 +22,7 @@ async function settleTimedOutBirth(paths) {
     }
     if (result === "sealed") {
         const seal = await readSeal(paths);
-        throw new Error(seal?.evidence === "call-timeout" || seal === null
-            ? "Akuma body failed before birth"
-            : seal.evidence);
+        throw new Error(seal?.evidence === "call-timeout" || seal === null ? "Akuma body failed before birth" : seal.evidence);
     }
     const soul = await readSoul(paths);
     if (soul === null)
@@ -57,7 +55,7 @@ async function awaitBirth(paths, signal) {
             if (settled !== null)
                 return settled;
         }
-        await abortableDelay(POLL_MS, signal);
+        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
     }
 }
 async function takeLeashUntil(paths, deadline) {
@@ -67,7 +65,7 @@ async function takeLeashUntil(paths, deadline) {
             return leash;
         if (performance.now() >= deadline)
             return null;
-        await abortableDelay(POLL_MS);
+        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
 async function awaitAsleepBirth(paths) {
@@ -98,7 +96,9 @@ async function sealLocalFailure(allocated, error) {
             leash.release();
         }
     }
-    catch { /* the original local publication failure remains authoritative */ }
+    catch {
+        /* the original local publication failure remains authoritative */
+    }
 }
 export async function publishAkuma(input) {
     input.signal?.throwIfAborted();

package/build/src/akuma/request-execution.d.ts

@@ -0,0 +1,6 @@
+import type { UpstreamRequestService } from "./heart/index.js";
+import type { ServeInput, UpstreamFact } from "./request-serve.js";
+export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<Readonly<{
+    result: unknown;
+    service?: UpstreamRequestService;
+}>>;

package/build/src/akuma/request-execution.js

@@ -0,0 +1,86 @@
+export async function executeRequest(input, request) {
+    if (input.upstream === undefined)
+        throw new Error("upstream execution port is unavailable");
+    if (request.action === "akuma.wait")
+        return {
+            result: await input.upstream.wait({
+                targets: request.targets,
+                completion: request.completion,
+                ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+                signal: input.signal,
+            }),
+            service: { action: request.action },
+        };
+    if (request.action === "akuma.tell")
+        return {
+            result: await input.upstream.tell({
+                target: request.target,
+                body: request.body,
+                tellId: request.id,
+                recordedAt: request.admittedAt,
+                signal: input.signal,
+            }),
+            service: { action: request.action, target: request.target, tellId: request.id },
+        };
+    if (request.action === "akuma.kill") {
+        const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
+        return { result: served.result, service: { action: request.action, results: served.service } };
+    }
+    if (request.action === "contract.deliver") {
+        const served = await input.upstream.deliver({
+            repoRoot: request.repoRoot,
+            contractId: request.contractId,
+            ...(request.message === undefined ? {} : { message: request.message }),
+            includeDirty: request.includeDirty,
+            materializeConflict: request.materializeConflict,
+            requester: request.requester,
+            signal: input.signal,
+        });
+        return {
+            result: served.result,
+            ...(served.deliveryFactId === undefined
+                ? {}
+                : {
+                    service: {
+                        action: request.action,
+                        repoRoot: request.repoRoot,
+                        contractId: request.contractId,
+                        deliveryFactId: served.deliveryFactId,
+                    },
+                }),
+        };
+    }
+    if (request.action === "contract.review") {
+        const served = await input.upstream.review({
+            repoRoot: request.repoRoot,
+            contractId: request.contractId,
+            verdict: request.verdict,
+            ...(request.summary === undefined ? {} : { summary: request.summary }),
+            requester: request.requester,
+            signal: input.signal,
+        });
+        return {
+            result: served.result,
+            ...(served.reviewFactId === undefined
+                ? {}
+                : {
+                    service: {
+                        action: request.action,
+                        repoRoot: request.repoRoot,
+                        contractId: request.contractId,
+                        reviewFactId: served.reviewFactId,
+                    },
+                }),
+        };
+    }
+    const task = request;
+    return {
+        result: await input.upstream.task({
+            world: task.world,
+            request: task.request,
+            requester: task.requester,
+            signal: input.signal,
+        }),
+        service: { action: task.action },
+    };
+}

package/build/src/akuma/request-serve.d.ts

@@ -1,5 +1,6 @@
-import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
 export type RequestChildLaunch = Readonly<{
     paths: AkumaPaths;
@@ -67,6 +68,16 @@ type PumpInput = Readonly<{
     upstream?: UpstreamExecutionPort;
     signal: AbortSignal;
 }>;
+export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
+    directory: string;
+    claim: StructuralRequestClaim;
+    admissionOpen(): boolean;
+}>;
+export type UpstreamFact = Exclude<Extract<RequestFact, {
+    state: "admitted";
+}>, Extract<RequestFact, {
+    action: "akuma.call";
+}>>;
 export declare class BodyRequestPump {
     private readonly input;
     readonly directory: string;