@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -0,0 +1,191 @@
+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.network !== undefined)
+        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 }),
+        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+    };
+}
+async function piCreateOptions(sdk, input) {
+    let model;
+    let modelRuntime;
+    if (input.options.model !== undefined) {
+        const slash = input.options.model.indexOf("/");
+        modelRuntime = await sdk.ModelRuntime.create();
+        model = modelRuntime.getModel(input.options.model.slice(0, slash), input.options.model.slice(slash + 1));
+        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(),
+        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"); })();
+    return {
+        cwd: input.cwd,
+        sessionManager,
+        ...(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 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");
+    }
+    const events = new AgentEventChannel();
+    const state = { answer: "", assistantSeen: false, tools: new Map() };
+    let terminalFailure = null;
+    let disposed = false;
+    let abortRequest;
+    let aborting = false;
+    let settled = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        try {
+            unsubscribe();
+        }
+        finally {
+            try {
+                native.dispose();
+            }
+            finally {
+                events.end();
+            }
+        }
+    };
+    const unsubscribe = native.subscribe((event) => {
+        if (event.type === "agent_end" && !event.willRetry)
+            terminalFailure = piTerminalFailure(event.messages);
+        for (const translated of translatePiEvent(event, state))
+            events.emit(translated);
+    });
+    events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
+    let settleCompletion;
+    const completion = new Promise((resolve) => { settleCompletion = resolve; });
+    const settle = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        dispose();
+        settleCompletion(result);
+    };
+    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;
+            }
+            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 }),
+            });
+        }
+        catch (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 {
+                    await native.abort();
+                }
+                catch { /* prompt settlement still proves local cleanup */ }
+                settle({ kind: "failed", diagnostic: "Pi session aborted" });
+            })();
+            return abortRequest;
+        },
+    };
+}
+function piSessionFile(coordinate) {
+    if (!("sessionFile" in coordinate))
+        throw new Error("Pi requires sessionFile");
+    return coordinate.sessionFile;
+}
+async function forkPi(sdk, input) {
+    const sessionFile = piSessionFile(input.session);
+    const manager = sdk.SessionManager.open(sessionFile);
+    const child = manager.createBranchedSession(input.at);
+    if (child === undefined || child === sessionFile)
+        throw new Error("Pi fork did not create a distinct child session file");
+    return { session: { sessionFile: child } };
+}
+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: admitPiOptions,
+        start: drive,
+        resume: async (input) => {
+            piSessionFile(input.session.coordinate);
+            return drive(input);
+        },
+        fork: async (input) => {
+            piSessionFile(input.session);
+            return forkPi(await load(), input);
+        },
+    };
+}

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,19 +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 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 {};