@astrosheep/keiyaku 4.6.7 → 4.6.8

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

@@ -0,0 +1,353 @@
+import { randomUUID } from "node:crypto";
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+// Pinned vendor CLI entry: the public SDK does not expose cancellation or selectors.
+import { DaemonClient } from "@getpaseo/client/internal/daemon-client";
+import { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "@getpaseo/client/internal/daemon-client-websocket-transport";
+import { abortable } from "../../abort.js";
+import { AKUMA_REQUESTS_ENTRY_ENV, akumaExecutionEnvironment } from "../execution-environment.js";
+import { PaseoTurn } from "./events.js";
+import { providerLifecycle } from "../lifecycle.js";
+const configSchema = z
+    .object({
+    url: z.string().default("ws://127.0.0.1:6767/ws"),
+    provider: z.string().trim().min(1).default("claude"),
+})
+    .strict();
+function failures(errors, message) {
+    if (errors.length === 1)
+        throw errors[0];
+    if (errors.length > 1)
+        throw new AggregateError(errors, message);
+}
+/** Native disposal forgets sockets before their close event and swallows close errors. */
+class PaseoSockets {
+    retiring = false;
+    errors = [];
+    sockets = [];
+    factory = (options) => {
+        if (this.retiring)
+            throw new Error("Paseo socket custody retired");
+        const native = createWebSocketTransportFactory((url, settings) => {
+            if (this.retiring)
+                throw new Error("Paseo socket custody retired");
+            const socket = defaultWebSocketFactory(url, settings);
+            let proveClosed;
+            const closed = new Promise((resolve) => {
+                proveClosed = resolve;
+            });
+            const owned = { socket, closed, observed: false };
+            const remove = bindWsHandler(socket, "close", () => {
+                owned.observed = true;
+                remove();
+                proveClosed();
+            });
+            this.sockets.push(owned);
+            return socket;
+        })(options);
+        return {
+            ...native,
+            close: (code, reason) => {
+                try {
+                    native.close(code, reason);
+                }
+                catch (error) {
+                    this.errors.push(error);
+                    throw error;
+                }
+            },
+        };
+    };
+    async retire(client) {
+        this.retiring = true;
+        // Begin logical retirement, but independently close saved sockets even if
+        // native disposal already forgot one after a rejected close code (1001).
+        const logical = (async () => {
+            try {
+                await client.close();
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        })();
+        const physical = [];
+        for (const owned of this.sockets) {
+            try {
+                if (!owned.observed)
+                    owned.socket.close(1000, "Paseo adapter retired");
+                physical.push(owned.closed);
+            }
+            catch (error) {
+                this.errors.push(error);
+                // No success proof for this socket; the Body's existing custody policy
+                // receives unsuccessful closure rather than a fabricated close event.
+            }
+        }
+        await Promise.all([logical, ...physical]);
+        failures(this.errors, "Paseo client/socket retirement failed");
+    }
+}
+/** Check before invoking native work, not only after creating its promise. */
+async function setup(signal, operation) {
+    signal.throwIfAborted();
+    const result = await abortable(operation(), signal);
+    signal.throwIfAborted();
+    return result;
+}
+function configuration(execution) {
+    if (execution.executable !== undefined)
+        throw new TypeError("Paseo connects to a local daemon, not an executable");
+    const parsed = configSchema.safeParse(execution.config ?? {});
+    if (!parsed.success)
+        throw new TypeError(`Paseo configuration: ${parsed.error.issues[0]?.message}`, { cause: parsed.error });
+    const config = parsed.data;
+    const url = new URL(config.url);
+    if (!["ws:", "wss:"].includes(url.protocol) ||
+        !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) ||
+        url.pathname !== "/ws" ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.search !== "" ||
+        url.hash !== "") {
+        throw new TypeError("Paseo url must be a loopback WebSocket endpoint ending in /ws");
+    }
+    if (config.provider.includes("/"))
+        throw new TypeError("Paseo provider must be a bare native provider id; use the model option separately");
+    return config;
+}
+function optionAdmission(options) {
+    if (options.network !== undefined)
+        return { kind: "refused", diagnostic: "Paseo does not support the network option" };
+    if (options.systemPromptMode === "replace")
+        return { kind: "refused", diagnostic: "Paseo does not support systemPrompt replacement" };
+    return { kind: "admitted", options };
+}
+function usable(agent, input, config) {
+    if (agent.archivedAt != null || agent.providerUnavailable || agent.status === "closed")
+        throw new Error(`Paseo agent ${agent.id} is unavailable`);
+    if (agent.cwd !== input.cwd || agent.provider !== config.provider)
+        throw new Error(`Paseo agent ${agent.id} no longer matches its execution recipe`);
+    if (agent.activeTurn != null || agent.status === "running" || agent.status === "initializing")
+        throw new Error(`Paseo agent ${agent.id} is busy; refusing to submit into another native execution`);
+}
+async function offeredModel(client, agent, input, config) {
+    const { model, effort } = input.options;
+    if (model === undefined && effort === undefined)
+        return undefined;
+    const catalog = await setup(input.signal, () => client.listProviderModels(config.provider, { cwd: input.cwd }));
+    if (catalog.error != null)
+        throw new Error(`Paseo selector catalog unavailable: ${catalog.error}`);
+    const requested = model ?? agent.runtimeInfo?.model ?? agent.model;
+    const selected = catalog.models?.find((choice) => choice.isSelectable !== false &&
+        (requested == null ? choice.isDefault : choice.id === requested || choice.aliases?.includes(requested)));
+    if (selected === undefined)
+        throw new Error(`Paseo model is not available: ${requested ?? "native default"}`);
+    if (effort !== undefined && !selected.thinkingOptions?.some((choice) => choice.id === effort)) {
+        throw new Error(`Paseo effort is not available for ${selected.id}: ${effort}`);
+    }
+    return model === undefined ? undefined : selected.id;
+}
+async function applyOptions(client, agent, input, config) {
+    usable(agent, input, config);
+    const model = await offeredModel(client, agent, input, config);
+    const { effort } = input.options;
+    if (model !== undefined)
+        await setup(input.signal, () => client.setAgentModel(agent.id, model));
+    if (effort !== undefined) {
+        const notice = await setup(input.signal, () => client.setAgentThinkingOption(agent.id, effort));
+        if (notice?.type === "error")
+            throw new Error(`Paseo effort refused: ${notice.message}`);
+    }
+    const observed = await setup(input.signal, () => client.fetchAgent(agent.id));
+    if (observed === null)
+        throw new Error(`Paseo agent ${agent.id} is unavailable`);
+    usable(observed.agent, input, config);
+    if (model !== undefined && (observed.agent.runtimeInfo?.model ?? observed.agent.model) !== model) {
+        throw new Error(`Paseo model selection was not confirmed: ${model}`);
+    }
+    if (effort !== undefined &&
+        (observed.agent.effectiveThinkingOptionId ?? observed.agent.runtimeInfo?.thinkingOptionId) !== effort) {
+        throw new Error(`Paseo effort selection was not confirmed: ${effort}`);
+    }
+}
+class PaseoDrive {
+    client;
+    environment;
+    sockets;
+    closed;
+    turn = new PaseoTurn(randomUUID());
+    proveClosed;
+    failClosed;
+    closure;
+    removeConnectionListener = () => undefined;
+    agentId;
+    submitted = false;
+    sequence;
+    epoch;
+    constructor(client, custody, environment, sockets) {
+        this.client = client;
+        this.environment = environment;
+        this.sockets = sockets;
+        this.closed = new Promise((resolve, reject) => {
+            this.proveClosed = resolve;
+            this.failClosed = reject;
+        });
+        custody.own({ closed: this.closed, abort: () => this.retire(true), forceDispose: () => this.retire(true) });
+        this.removeConnectionListener = client.subscribeConnectionStatus((state) => {
+            if (this.closure !== undefined)
+                return;
+            if (state.status === "disconnected" || state.status === "disposed")
+                this.turn.fail(new Error("Paseo connection lost before own turn completion"));
+        });
+    }
+    async establish(input, config, coordinate) {
+        const entry = input.requests.entry;
+        if (entry === undefined || !isAbsolute(entry) || resolve(entry) !== entry)
+            throw new Error("Paseo requires the Body's stable request entry");
+        input.signal.throwIfAborted();
+        await setup(input.signal, () => this.client.connect());
+        const agent = coordinate === undefined
+            ? await setup(input.signal, () => this.client.createAgent({
+                provider: config.provider,
+                cwd: input.cwd,
+                ...(input.options.systemPrompt === undefined ? {} : { systemPrompt: input.options.systemPrompt }),
+                env: { ...akumaExecutionEnvironment(process.env, this.environment), [AKUMA_REQUESTS_ENTRY_ENV]: entry },
+                autoArchive: false,
+            }))
+            : await this.existingAgent(coordinate, input.signal);
+        this.agentId = agent.id;
+        await applyOptions(this.client, agent, input, config);
+        input.signal.throwIfAborted();
+        const subscription = this.client.subscribeAgentTimeline(agent.id, (message) => this.receive(message));
+        await abortable(subscription.ready, input.signal);
+        this.turn.events.emit({ type: "session", coordinate: { sessionId: agent.id } });
+        // Native steer may still replace work if a human wins the check/send race.
+        input.signal.throwIfAborted();
+        const parts = [input.body, ...input.launchTells.map((tell) => tell.text)];
+        if (input.schemaJson !== undefined) {
+            parts.push("Respond with JSON matching this JSON Schema and no other text:", input.schemaJson);
+        }
+        const prompt = parts.filter((text) => text.length > 0).join("\n\n");
+        await setup(input.signal, () => {
+            this.submitted = true;
+            return this.client.sendMessage(agent.id, prompt, { messageId: this.turn.messageId, activeTurnBehavior: "steer" });
+        });
+        const admissionSignal = AbortSignal.any([input.signal, AbortSignal.timeout(15_000)]);
+        const fence = await abortable(this.turn.admission, admissionSignal).catch((error) => {
+            if (input.signal.aborted)
+                throw error;
+            throw new Error("Paseo canonical native admission was not observed", { cause: error });
+        });
+        const completion = this.finish();
+        void completion.catch(() => undefined);
+        return {
+            admission: { fence },
+            events: this.turn.events,
+            completion,
+            abort: () => this.retire(true),
+            forceDispose: () => this.retire(true),
+        };
+    }
+    async existingAgent(coordinate, signal) {
+        if (!("sessionId" in coordinate) || coordinate.sessionId === undefined || "sessionFile" in coordinate)
+            throw new Error("Paseo resume requires an agent id");
+        const found = await setup(signal, () => this.client.fetchAgent(coordinate.sessionId));
+        if (found === null)
+            throw new Error(`Paseo agent ${coordinate.sessionId} is unavailable`);
+        return found.agent;
+    }
+    receive(message) {
+        if (this.closure !== undefined || message.payload.agentId !== this.agentId)
+            return;
+        if (message.type === "agent_stream") {
+            const { seq, epoch, event } = message.payload;
+            if (this.epoch !== undefined && epoch !== undefined && epoch !== this.epoch)
+                return this.turn.fail(new Error("Paseo timeline epoch changed before own turn completion"));
+            if (epoch !== undefined)
+                this.epoch = epoch;
+            if (seq !== undefined) {
+                if (this.sequence !== undefined && seq > this.sequence + 1)
+                    return this.turn.fail(new Error("Paseo timeline delivery gap before own turn completion"));
+                if (this.sequence !== undefined && seq <= this.sequence)
+                    return;
+                this.sequence = seq;
+            }
+            this.turn.receive(event);
+        }
+        else
+            this.turn.fail(new Error(message.type === "agent.timeline.error"
+                ? `Paseo timeline failed: ${message.payload.error}`
+                : "Paseo timeline was invalidated before own turn completion"));
+    }
+    async finish() {
+        try {
+            const result = await this.turn.completion;
+            await this.retire(false);
+            return result;
+        }
+        catch (error) {
+            try {
+                await this.retire(true);
+            }
+            catch {
+                // Attempt closure retains the control or client-retirement failure independently.
+            }
+            throw error;
+        }
+    }
+    retire(cancel) {
+        return (this.closure ??= this.close(cancel));
+    }
+    async close(cancel) {
+        this.removeConnectionListener();
+        try {
+            const errors = [];
+            try {
+                if (cancel && this.submitted && !this.turn.terminal && this.agentId !== undefined)
+                    await this.client.cancelAgent(this.agentId);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await this.sockets.retire(this.client);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            failures(errors, "Paseo native control and retirement failed");
+            this.proveClosed();
+        }
+        catch (error) {
+            this.failClosed(error);
+            throw error;
+        }
+        finally {
+            this.turn.fail(new Error("Paseo client retired"));
+            this.turn.events.end();
+        }
+    }
+}
+export function createPaseoProvider(execution, dependencies = {}) {
+    const config = configuration(execution);
+    return {
+        admitOptions: optionAdmission,
+        ...providerLifecycle(async (input, custody) => {
+            custody.signal.throwIfAborted();
+            const environment = akumaExecutionEnvironment(process.env, execution.env);
+            const sockets = new PaseoSockets();
+            const client = (dependencies.createClient ?? ((value) => new DaemonClient(value)))({
+                url: config.url,
+                clientId: randomUUID(),
+                clientType: "cli",
+                reconnect: { enabled: false },
+                transportFactory: sockets.factory,
+                connectTimeoutMs: 15_000,
+                ...(environment.PASEO_PASSWORD === undefined ? {} : { password: environment.PASEO_PASSWORD }),
+            });
+            const drive = new PaseoDrive(client, custody, execution.env ?? {}, sockets);
+            const signal = AbortSignal.any([custody.signal, AbortSignal.timeout(15_000)]);
+            return await drive.establish({ ...input, signal }, config, input.session.kind === "resume" ? input.session.coordinate : undefined);
+        }),
+    };
+}

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

@@ -1,4 +1,5 @@
 import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { nonblank, positiveLine, searchToolCall } from "../decode.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
@@ -51,12 +52,6 @@ function hasTextContent(content) {
             return value?.type === "text" && typeof value.text === "string";
         }));
 }
-function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
-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;
 }
@@ -78,15 +73,10 @@ function searchCall(name, value) {
     const query = value.pattern ?? value.query;
     if (typeof query !== "string")
         return undefined;
-    const path = optionalText(value.path);
-    const glob = optionalText(value.glob);
-    return {
-        kind: "search",
-        query,
-        scope: name === "find" ? "files" : "content",
-        ...(path === undefined ? {} : { path }),
-        ...(name === "grep" && glob !== undefined ? { glob } : {}),
-    };
+    return searchToolCall(query, name === "find" ? "files" : "content", {
+        path: nonblank(value.path),
+        glob: name === "grep" ? nonblank(value.glob) : undefined,
+    });
 }
 function fileChangeCall(name, value) {
     // Native write cannot prove creation versus overwrite and reports no patch, so

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

@@ -1,3 +1,4 @@
+import { type AkumaCaller } from "./caller.js";
 import { type Soul } from "./heart/index.js";
 import { type AllocatedAkuma, type AkumaPaths, type AkuId } from "./identity.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
@@ -81,6 +82,7 @@ type PreparedCallResult = Readonly<{
 type PreparedCallInput = Readonly<{
     archetype: string;
     cwd: string;
+    caller?: AkumaCaller;
     initialTell?: CallInitialTell;
     signal?: AbortSignal;
     custody: PreparedCallCustody;

package/build/src/akuma/publication.js

@@ -1,3 +1,4 @@
+import { decodeAkumaCaller } from "./caller.js";
 import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul } from "./heart/index.js";
 import { acquireLeash } from "./control.js";
 import { allocateAkumaDirectory } from "./identity.js";
@@ -337,6 +338,9 @@ async function durablyBorn(allocated) {
  */
 export async function executePreparedCall(input) {
     const { custody } = input;
+    const caller = custody.kind === "request"
+        ? { kind: "akuma", world: custody.world, akuId: custody.parent.id }
+        : decodeAkumaCaller(input.caller);
     let world;
     if (custody.kind === "local") {
         world = custody.world;
@@ -383,6 +387,7 @@ export async function executePreparedCall(input) {
                         allowed: recipe.allowed,
                         cwd: input.cwd,
                         origin,
+                        ...(caller === undefined ? {} : { caller }),
                     },
                 });
             },

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

@@ -19,6 +19,7 @@ export declare class BodyRequestPump {
     private readonly input;
     private readonly serveClaim;
     readonly directory: string;
+    readonly entry: string;
     readonly failure: Promise<never>;
     private readonly closeSignal;
     private readonly executionSignal;
@@ -26,10 +27,12 @@ export declare class BodyRequestPump {
     private readonly running;
     private readonly cancelBody;
     private admissionClosed;
+    private closure;
     protected constructor(input: PumpInput, serveClaim: ServeClaim);
     static openWithService(input: PumpInput, serveClaim: ServeClaim): Promise<BodyRequestPump>;
     private run;
     close(): Promise<void>;
+    private closeTransport;
     stopAdmission(): void;
 }
 export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;

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

@@ -4,12 +4,13 @@ import { abortableDelay } from "./abort.js";
 import { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, unproveRequest, voidRequest, } from "./heart/index.js";
 import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
-import { decodeEnvelope } from "./request-wire.js";
+import { atomicJson, decodeEnvelope } from "./request-wire.js";
 const POLL_MS = 100;
 export class BodyRequestPump {
     input;
     serveClaim;
     directory;
+    entry;
     failure;
     closeSignal = new AbortController();
     executionSignal = new AbortController();
@@ -17,10 +18,12 @@ export class BodyRequestPump {
     running;
     cancelBody;
     admissionClosed = false;
+    closure;
     constructor(input, serveClaim) {
         this.input = input;
         this.serveClaim = serveClaim;
         this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
+        this.entry = join(input.paths.directory, "request-entry.json");
         this.cancelBody = () => {
             this.stopAdmission();
             if (!this.executionSignal.signal.aborted)
@@ -33,7 +36,16 @@ export class BodyRequestPump {
         this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
     }
     static async openWithService(input, serveClaim) {
-        await mkdir(join(input.paths.directory, "requests", String(input.bodySequence)), { recursive: true });
+        input.signal.throwIfAborted();
+        const directory = join(input.paths.directory, "requests", String(input.bodySequence));
+        await mkdir(directory, { recursive: true });
+        try {
+            await atomicJson(join(input.paths.directory, "request-entry.json"), { directory }, input.signal);
+        }
+        catch (error) {
+            await rm(directory, { recursive: true, force: true });
+            throw error;
+        }
         return new BodyRequestPump(input, serveClaim);
     }
     async run() {
@@ -84,12 +96,20 @@ export class BodyRequestPump {
             }
         }
     }
-    async close() {
+    close() {
+        return (this.closure ??= this.closeTransport());
+    }
+    async closeTransport() {
         this.stopAdmission();
         if (!this.executionSignal.signal.aborted)
             this.executionSignal.abort(new Error("Body request pump closed"));
         try {
-            await this.running;
+            try {
+                await rm(this.entry, { force: true });
+            }
+            finally {
+                await this.running;
+            }
         }
         finally {
             this.input.signal.removeEventListener("abort", this.cancelBody);
@@ -103,6 +123,7 @@ export class BodyRequestPump {
     }
 }
 export async function clearBodyRequestTransport(paths) {
+    await rm(join(paths.directory, "request-entry.json"), { force: true });
     await rm(join(paths.directory, "requests"), { recursive: true, force: true });
 }
 async function requestFiles(directory) {

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

@@ -1,5 +1,5 @@
 export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
-export type ExecutionChannel = Readonly<{
+type ExecutionChannel = Readonly<{
     kind: "local";
 }> | Readonly<{
     kind: "body-request";
@@ -15,4 +15,6 @@ export declare function bodyRequestExecutionContext(directory: unknown): Executi
 export declare function bodyRequestExecution(input: Readonly<{
     directory: string;
 }>): LibraryExecution;
+/** Resolve persistent transport once at private process composition, never during an operation. */
+export declare function executionForEnvironment(environment: Readonly<Record<string, string | undefined>>, signal?: AbortSignal): Promise<LibraryExecution>;
 export declare function executionChannel(context?: ExecutionContext): ExecutionChannel;

package/build/src/akuma/requests.js

@@ -1,4 +1,6 @@
+import { readFile } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
+import { AKUMA_REQUESTS_ENTRY_ENV, AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
 export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
 const LOCAL_CHANNEL = Object.freeze({ kind: "local" });
 export function localExecutionContext() {
@@ -35,6 +37,36 @@ export function bodyRequestExecution(input) {
         throw new TypeError(error instanceof Error ? error.message : String(error));
     }
 }
+/** Resolve persistent transport once at private process composition, never during an operation. */
+export async function executionForEnvironment(environment, signal) {
+    signal?.throwIfAborted();
+    const directory = environment[AKUMA_REQUESTS_ENV];
+    const entry = environment[AKUMA_REQUESTS_ENTRY_ENV];
+    if (entry === undefined)
+        return directory === undefined ? localExecutionContext() : bodyRequestExecution({ directory });
+    if (directory !== undefined)
+        throw new TypeError("AKUMA_REQUESTS and AKUMA_REQUESTS_ENTRY are mutually exclusive");
+    if (!isAbsolute(entry) || resolve(entry) !== entry) {
+        throw new TypeError("AKUMA_REQUESTS_ENTRY must be an absolute normalized path");
+    }
+    let serialized;
+    try {
+        serialized = await readFile(entry, { encoding: "utf8", signal });
+    }
+    catch (error) {
+        signal?.throwIfAborted();
+        throw new Error(`Akuma stable request entry unavailable: no current request channel at ${entry}`, { cause: error });
+    }
+    signal?.throwIfAborted();
+    try {
+        const value = valueRecord(JSON.parse(serialized), "body request entry");
+        closed(value, ["directory"], "body request entry");
+        return bodyRequestExecution({ directory: value.directory });
+    }
+    catch (error) {
+        throw new TypeError(`Akuma stable request entry malformed at ${entry}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
 export function executionChannel(context) {
     return context?.channel ?? LOCAL_CHANNEL;
 }