@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/akuma/providers/pi/index.d.ts

@@ -0,0 +1,11 @@
+import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { ProviderExecution } from "../../heart/index.js";
+import { type ProviderAdapter } from "../../provider.js";
+export type PiSdk = Readonly<{
+    createAgentSession(options?: CreateAgentSessionOptions): ReturnType<typeof createAgentSession>;
+    DefaultResourceLoader: typeof DefaultResourceLoader;
+    getAgentDir: typeof getAgentDir;
+    ModelRuntime: typeof ModelRuntime;
+    SessionManager: typeof SessionManager;
+}>;
+export declare function createPiProvider(execution?: ProviderExecution, load?: () => Promise<PiSdk>): ProviderAdapter;

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

@@ -0,0 +1,162 @@
+import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+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" };
+    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 }) };
+}
+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 }),
+    };
+}
+async function drivePi(sdk, input) {
+    const created = await sdk.createAgentSession(await piCreateOptions(sdk, input));
+    const native = created.session;
+    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 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 (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(historyId === null
+                ? { kind: "failed", diagnostic: "Pi completed without a forkable history entry" }
+                : { kind: "answered", answer: state.answer, historyId });
+        }
+        catch (error) {
+            settle({ kind: "failed", diagnostic: diagnostic(error) });
+        }
+    })();
+    return {
+        admission: { fence: native.sessionId }, events, completion,
+        abort: () => {
+            abortRequest ??= (async () => {
+                try {
+                    void native.abort().catch(() => undefined);
+                }
+                catch { /* best effort: local settlement already owns lifecycle */ }
+                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) {
+    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),
+        resume: async (input) => {
+            piSessionFile(input.session.coordinate);
+            return drivePi(await load(), input);
+        },
+        fork: async (input) => {
+            piSessionFile(input.session);
+            return forkPi(await load(), input);
+        },
+    };
+}

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

@@ -0,0 +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>;
+}>): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -0,0 +1,107 @@
+import { HeldAkumaLeash, initializeHeart, readHeart, readSoul, } from "./heart/index.js";
+import { allocateAkumaDirectory, } from "./identity.js";
+import { probeProcessTree } from "../runtime/proc/run.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);
+    if (leash === null)
+        return null;
+    const result = 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);
+    if (soul === null)
+        throw new Error("Akuma birth settled without a soul");
+    return soul;
+}
+async function awaitBirth(paths) {
+    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
+    for (;;) {
+        const soul = readSoul(paths);
+        if (soul !== null)
+            return soul;
+        if (performance.now() >= deadline) {
+            const settled = settleTimedOutBirth(paths);
+            if (settled !== null)
+                return settled;
+        }
+        await wait(POLL_MS);
+    }
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(POLL_MS);
+    }
+}
+async function awaitAsleepBirth(paths, collar) {
+    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") {
+            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) {
+    try {
+        const leash = HeldAkumaLeash.try(allocated.paths);
+        if (leash === null)
+            return;
+        try {
+            leash.sealIfUnborn(allocated.paths, { evidence: diagnostic(error), at: new Date().toISOString() });
+        }
+        finally {
+            leash.release();
+        }
+    }
+    catch { /* the original local publication failure remains authoritative */ }
+}
+export async function publishAkuma(input) {
+    const allocated = allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
+    let collar;
+    try {
+        initializeHeart(allocated.paths);
+        input.reserve?.(allocated);
+        collar = await input.launch(allocated);
+    }
+    catch (error) {
+        sealLocalFailure(allocated, error);
+        throw error;
+    }
+    const soul = await awaitBirth(allocated.paths);
+    if (soul.id !== allocated.id)
+        throw new Error("Akuma birth returned a different identity");
+    if (input.awaitAsleep === true)
+        await awaitAsleepBirth(allocated.paths, collar);
+    return allocated;
+}

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

@@ -0,0 +1,47 @@
+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;
+    archetype: string;
+    body: string;
+    cwd?: string;
+    recipe: RequestRecipe;
+}>;
+export type RequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+export declare class AkumaBodyRequestError extends Error {
+    readonly outcome: "refused" | "voided";
+    readonly diagnostic: string;
+    readonly kind = "akuma-body-request";
+    constructor(outcome: "refused" | "voided", diagnostic: string);
+}
+export declare function injectedBodyRequests(): string | null;
+export declare function requestBodyCall(input: RequestClaim & Readonly<{
+    directory: string;
+}>): Promise<AkuId>;
+export declare class BodyRequestPump {
+    private readonly input;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private closed;
+    private readonly handled;
+    private readonly running;
+    constructor(input: Readonly<{
+        paths: AkumaPaths;
+        parent: Soul;
+        bodySequence: number;
+        now(): string;
+        spawn(launch: RequestChildLaunch): Promise<ProcessCollar>;
+    }>);
+    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 {};