@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -1,21 +1,24 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { abortable } from "../../abort.js";
 import { 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 admitPiOptions(options) {
-    if (options.access !== undefined)
-        return { kind: "refused", diagnostic: "Pi provider does not support the Archetype access option" };
     if (options.network !== undefined)
-        return { kind: "refused", diagnostic: "Pi provider does not support the Archetype network option" };
+        return { kind: "refused", diagnostic: "Pi provider does not support the network option" };
     if (options.model !== undefined && !MODEL_PATTERN.test(options.model)) {
         return { kind: "refused", diagnostic: "Pi provider model must use <provider>/<id>" };
     }
     if (options.effort !== undefined && !PI_THINKING_LEVELS.has(options.effort)) {
         return { kind: "refused", diagnostic: "Pi provider effort must be minimal, low, medium, high, xhigh, or max" };
     }
-    return { kind: "admitted", options: Object.freeze({ ...options }) };
+    return {
+        kind: "admitted",
+        options: Object.freeze({ ...options }),
+        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+    };
 }
 async function piCreateOptions(sdk, input) {
     let model;
@@ -44,11 +47,20 @@ async function piCreateOptions(sdk, input) {
         ...(model === undefined || modelRuntime === undefined ? {} : { model, modelRuntime }),
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
+        ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
     };
 }
-async function drivePi(sdk, input) {
-    const created = await sdk.createAgentSession(await piCreateOptions(sdk, input));
+async function createPiSession(sdk, input, signal) {
+    const setup = piCreateOptions(sdk, input).then(async (options) => await sdk.createAgentSession(options));
+    return await abortable(setup, signal, (created) => created.session.dispose());
+}
+async function drivePi(sdk, input, signal) {
+    const created = await createPiSession(sdk, input, signal);
     const native = created.session;
+    if (signal.aborted) {
+        native.dispose();
+        signal.throwIfAborted();
+    }
     if (native.sessionFile === undefined || native.sessionFile.trim().length === 0) {
         native.dispose();
         throw new Error("Pi session admitted without sessionFile");
@@ -58,6 +70,7 @@ async function drivePi(sdk, input) {
     let terminalFailure = null;
     let disposed = false;
     let abortRequest;
+    let aborting = false;
     let settled = false;
     const dispose = () => {
         if (disposed)
@@ -94,6 +107,10 @@ async function drivePi(sdk, input) {
     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;
@@ -103,22 +120,29 @@ async function drivePi(sdk, input) {
                 return;
             }
             const historyId = native.sessionManager.getLeafId();
-            settle(historyId === null
-                ? { kind: "failed", diagnostic: "Pi completed without a forkable history entry" }
-                : { kind: "answered", answer: state.answer, historyId });
+            settle({
+                kind: "answered",
+                answer: state.answer,
+                ...(historyId === null ? {} : { historyId }),
+            });
         }
         catch (error) {
-            settle({ kind: "failed", diagnostic: diagnostic(error) });
+            settle(aborting
+                ? { kind: "failed", diagnostic: "Pi session aborted" }
+                : { kind: "failed", diagnostic: diagnostic(error) });
         }
     })();
     return {
         admission: { fence: native.sessionId }, events, completion,
         abort: () => {
             abortRequest ??= (async () => {
+                if (settled)
+                    return;
+                aborting = true;
                 try {
-                    void native.abort().catch(() => undefined);
+                    await native.abort();
                 }
-                catch { /* best effort: local settlement already owns lifecycle */ }
+                catch { /* prompt settlement still proves local cleanup */ }
                 settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
             return abortRequest;
@@ -140,19 +164,24 @@ async function forkPi(sdk, input) {
 }
 const defaultSdk = { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager };
 export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = async () => defaultSdk) {
+    if (execution.executable !== undefined || execution.config !== undefined) {
+        throw new TypeError("Pi provider does not support executable or config");
+    }
+    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 {
         confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
-        admitOptions(options) {
-            if (execution.executable !== undefined || execution.config !== undefined)
-                return { kind: "refused", diagnostic: "Pi provider does not support executable or config" };
-            if (execution.env !== undefined && Object.keys(execution.env).length > 0)
-                return { kind: "refused", diagnostic: "env injection not supported for provider pi" };
-            return admitPiOptions(options);
-        },
-        start: async (input) => drivePi(await load(), input),
+        admitOptions: admitPiOptions,
+        start: drive,
         resume: async (input) => {
             piSessionFile(input.session.coordinate);
-            return drivePi(await load(), input);
+            return drive(input);
         },
         fork: async (input) => {
             piSessionFile(input.session);

package/build/src/akuma/publication.d.ts

@@ -1,10 +1,10 @@
 import { type AllocatedAkuma } from "./identity.js";
-import { type ProcessCollar } from "../runtime/proc/run.js";
 export declare const BIRTH_TIMEOUT_MS = 5000;
 export declare function publishAkuma(input: Readonly<{
     worldPath: string;
     archetype: string;
     awaitAsleep?: boolean;
-    reserve?(allocated: AllocatedAkuma): void;
-    launch(allocated: AllocatedAkuma): Promise<ProcessCollar>;
+    reserve?(allocated: AllocatedAkuma): Promise<void>;
+    launch(allocated: AllocatedAkuma): Promise<void>;
+    signal?: AbortSignal;
 }>): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -1,84 +1,69 @@
 import { HeldAkumaLeash, initializeHeart, readHeart, readSoul, } from "./heart/index.js";
 import { allocateAkumaDirectory, } from "./identity.js";
-import { probeProcessTree } from "../runtime/proc/run.js";
+import { abortableDelay } from "./abort.js";
 const POLL_MS = 25;
 export const BIRTH_TIMEOUT_MS = 5_000;
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function settleTimedOutBirth(paths) {
-    const leash = HeldAkumaLeash.try(paths);
+async function settleTimedOutBirth(paths) {
+    const leash = await HeldAkumaLeash.try(paths);
     if (leash === null)
         return null;
-    const result = leash.sealIfUnborn(paths, { evidence: "call-timeout", at: new Date().toISOString() });
+    const result = await leash.sealIfUnborn(paths, { evidence: "call-timeout", at: new Date().toISOString() });
     if (result === "sealed")
         throw new Error("Akuma body failed before birth");
     leash.release();
-    const soul = readSoul(paths);
+    const soul = await readSoul(paths);
     if (soul === null)
         throw new Error("Akuma birth settled without a soul");
     return soul;
 }
-async function awaitBirth(paths) {
+async function awaitBirth(paths, signal) {
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
-        const soul = readSoul(paths);
+        signal?.throwIfAborted();
+        const soul = await readSoul(paths);
         if (soul !== null)
             return soul;
         if (performance.now() >= deadline) {
-            const settled = settleTimedOutBirth(paths);
+            const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
                 return settled;
         }
-        await wait(POLL_MS);
+        await abortableDelay(POLL_MS, signal);
     }
 }
 async function takeLeashUntil(paths, deadline) {
     for (;;) {
-        const leash = HeldAkumaLeash.try(paths);
+        const leash = await HeldAkumaLeash.try(paths);
         if (leash !== null)
             return leash;
         if (performance.now() >= deadline)
             return null;
-        await wait(POLL_MS);
+        await abortableDelay(POLL_MS);
     }
 }
-async function awaitAsleepBirth(paths, collar) {
+async function awaitAsleepBirth(paths) {
     const leash = await takeLeashUntil(paths, performance.now() + BIRTH_TIMEOUT_MS);
     if (leash === null)
         throw new Error("Forked Akuma did not finish its birth body");
     try {
-        if (readHeart(paths).latestBody?.end !== "exited") {
+        if ((await readHeart(paths)).latestBody?.end !== "exited") {
             throw new Error("Forked Akuma birth body did not exit cleanly");
         }
     }
     finally {
         leash.release();
     }
-    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
-    for (;;) {
-        const probe = probeProcessTree(collar);
-        if (probe.kind === "gone")
-            return;
-        if (performance.now() >= deadline) {
-            if (probe.kind === "unverifiable") {
-                throw new Error(`Forked Akuma birth collar is unverifiable: ${probe.diagnostic}`);
-            }
-            throw new Error("Forked Akuma birth process did not exit");
-        }
-        await wait(POLL_MS);
-    }
 }
-function sealLocalFailure(allocated, error) {
+async function sealLocalFailure(allocated, error) {
     try {
-        const leash = HeldAkumaLeash.try(allocated.paths);
+        const leash = await HeldAkumaLeash.try(allocated.paths);
         if (leash === null)
             return;
         try {
-            leash.sealIfUnborn(allocated.paths, { evidence: diagnostic(error), at: new Date().toISOString() });
+            await leash.sealIfUnborn(allocated.paths, { evidence: diagnostic(error), at: new Date().toISOString() });
         }
         finally {
             leash.release();
@@ -87,21 +72,24 @@ function sealLocalFailure(allocated, error) {
     catch { /* the original local publication failure remains authoritative */ }
 }
 export async function publishAkuma(input) {
-    const allocated = allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
-    let collar;
+    input.signal?.throwIfAborted();
+    const allocated = await allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
     try {
-        initializeHeart(allocated.paths);
-        input.reserve?.(allocated);
-        collar = await input.launch(allocated);
+        await initializeHeart(allocated.paths);
+        input.signal?.throwIfAborted();
+        await input.reserve?.(allocated);
+        input.signal?.throwIfAborted();
+        await input.launch(allocated);
+        input.signal?.throwIfAborted();
     }
     catch (error) {
-        sealLocalFailure(allocated, error);
+        await sealLocalFailure(allocated, error);
         throw error;
     }
-    const soul = await awaitBirth(allocated.paths);
+    const soul = await awaitBirth(allocated.paths, input.signal);
     if (soul.id !== allocated.id)
         throw new Error("Akuma birth returned a different identity");
     if (input.awaitAsleep === true)
-        await awaitAsleepBirth(allocated.paths, collar);
+        await awaitAsleepBirth(allocated.paths);
     return allocated;
 }

package/build/src/akuma/requests.d.ts

@@ -1,6 +1,5 @@
 import { type RequestRecipe, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import type { ProcessCollar } from "../runtime/proc/run.js";
 type RequestClaim = Readonly<{
     id: string;
     world: string;
@@ -28,20 +27,23 @@ export declare class BodyRequestPump {
     private readonly input;
     readonly directory: string;
     readonly failure: Promise<never>;
-    private closed;
+    private readonly closeSignal;
     private readonly handled;
     private readonly running;
-    constructor(input: Readonly<{
+    private readonly cancelAdmission;
+    private constructor();
+    static open(input: Readonly<{
         paths: AkumaPaths;
         parent: Soul;
         bodySequence: number;
         now(): string;
-        spawn(launch: RequestChildLaunch): Promise<ProcessCollar>;
-    }>);
+        spawn(launch: RequestChildLaunch): Promise<void>;
+        signal: AbortSignal;
+    }>): Promise<BodyRequestPump>;
     private run;
     close(): Promise<void>;
     stopAdmission(): void;
 }
-export declare function clearBodyRequestTransport(paths: AkumaPaths): void;
-export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string): Promise<"settled" | "pending">;
+export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
 export {};