@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -0,0 +1,357 @@
+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 { launchPrompt, modelEvent, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENTRY_ENV, akumaExecutionEnvironment } from "../execution-environment.js";
+import { PaseoTurn, paseoRuntimeModel } 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}`);
+    }
+    // The runtime's own answer names the model this agent will run, whether or
+    // not the caller requested one. The snapshot's top-level model may be a
+    // configured fallback rather than what the runtime loaded, so it is never
+    // runtime evidence; an unnamed runtime stays unknown and clears nothing.
+    return paseoRuntimeModel(observed.agent.runtimeInfo);
+}
+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;
+        const startupModel = 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 } });
+        if (startupModel !== undefined)
+            this.turn.events.emit(modelEvent(startupModel));
+        // Native steer may still replace work if a human wins the check/send race.
+        input.signal.throwIfAborted();
+        const prompt = launchPrompt(input.body, input.launchTells, input.schemaJson);
+        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.d.ts

@@ -25,6 +25,8 @@ export declare const PI_EVENT_DISPOSITIONS: {
     readonly turn_end: "drop";
     readonly turn_start: "drop";
 };
+/** The model this native session will run, from its own selection. */
+export declare function piSessionModel(selected: unknown): string | undefined;
 export type PiEventState = {
     answer: string;
     assistantSeen: boolean;

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

@@ -1,4 +1,5 @@
-import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { modelEvent, noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { nonblank, observedTextContent, positiveLine, searchToolCall } from "../decode.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
@@ -31,31 +32,25 @@ function record(value) {
         : null;
 }
 function textContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((block) => {
-        const value = record(block);
-        return value?.type === "text" && typeof value.text === "string" ? value.text : "";
-    })
-        .join("");
+    return observedTextContent(content) ?? "";
 }
 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";
-        }));
-}
-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;
+    return observedTextContent(content) !== undefined;
+}
+/**
+ * Pi identifies a model as `<provider>/<id>`, the same convention its model
+ * option uses. The selected model and every recorded response carry both
+ * halves; a response without them names no model and stays unknown.
+ */
+function piModel(provider, id) {
+    const owner = nonblank(provider);
+    const name = nonblank(id);
+    return owner === undefined || name === undefined ? undefined : `${owner}/${name}`;
+}
+/** The model this native session will run, from its own selection. */
+export function piSessionModel(selected) {
+    const value = record(selected);
+    return piModel(value?.provider, value?.id);
 }
 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
@@ -99,13 +89,14 @@ function refineEditCall(call, result) {
     if (call.kind !== "fileChange")
         return call;
     const details = record(record(result)?.details);
-    if (typeof details?.patch !== "string")
+    const patch = typeof details?.patch === "string" ? details.patch : undefined;
+    if (patch === undefined)
         return call;
-    const diffstat = diffstatFromUnifiedPatch(details.patch);
+    const diffstat = diffstatFromUnifiedPatch(patch);
     const change = call.changes[0];
-    if (diffstat === undefined || change === undefined)
+    if (change === undefined)
         return call;
-    return { kind: "fileChange", changes: [{ ...change, diffstat }] };
+    return { kind: "fileChange", changes: [{ ...change, ...(diffstat === undefined ? {} : { diffstat }), patch }] };
 }
 function toolCall(name, args) {
     const value = record(args) ?? {};
@@ -131,6 +122,7 @@ function translateToolEnd(event, state) {
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
     const call = started?.call ?? otherToolCall(name);
+    const output = observedTextContent(record(event.result)?.content);
     return [
         {
             type: "tool",
@@ -138,7 +130,10 @@ function translateToolEnd(event, state) {
             id: event.toolCallId,
             name,
             call: event.isError ? call : refineEditCall(call, event.result),
-            result: { status: event.isError ? "error" : "ok" },
+            result: {
+                status: event.isError ? "error" : "ok",
+                ...(output === undefined ? {} : { output }),
+            },
         },
     ];
 }
@@ -147,6 +142,9 @@ function translateMessage(event, state) {
     if (message?.role !== "assistant")
         return [];
     const translated = [];
+    const model = piModel(message.provider, message.model);
+    if (model !== undefined)
+        translated.push(modelEvent(model));
     if (Array.isArray(message.content)) {
         for (const block of message.content) {
             const value = record(block);

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

@@ -1,7 +1,7 @@
 import { abortable } from "../../abort.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
-import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
-import { piTerminalFailure, translatePiEvent } from "./events.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, tellRegistry, } from "../../provider.js";
+import { piSessionModel, 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) {
@@ -83,15 +83,7 @@ async function createPiSession(sdk, execution, input) {
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
-        const prompt = [input.body, ...input.launchTells.map((tell) => tell.text)]
-            .filter((part) => part.length > 0)
-            .join("\n\n");
-        const schemaPrompt = input.schemaJson === undefined
-            ? prompt
-            : [prompt, "Respond with JSON matching this JSON Schema and no other text:", input.schemaJson]
-                .filter((part) => part.length > 0)
-                .join("\n\n");
-        await native.prompt(schemaPrompt);
+        await native.prompt(launchPrompt(input.body, input.launchTells, input.schemaJson));
         let result;
         if (state.aborting)
             result = { kind: "failed", diagnostic: "Pi session aborted" };
@@ -162,17 +154,15 @@ async function drivePi(sdk, execution, input, signal, custody) {
         aborting: false,
         settled: false,
     };
-    const pendingTells = new Map();
-    const endPendingTells = () => {
-        for (const waiter of pendingTells.values())
-            waiter.resolve({ kind: "turn-ended" });
-        pendingTells.clear();
-    };
+    const tells = tellRegistry((id) => `${native.sessionId}:${id}`);
     let settleCompletion;
     const completion = new Promise((resolve) => {
         settleCompletion = resolve;
     });
     const agent = native.agent;
+    // Tells are harness input, not interactive typing: deliver every queued one at
+    // the next boundary regardless of the user's interactive Pi setting.
+    agent.steeringMode = "all";
     let unsubscribeAgent;
     let unsubscribe;
     let binding;
@@ -180,7 +170,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
         if (state.settled)
             return closed;
         state.settled = true;
-        endPendingTells();
+        tells.end();
         let failure;
         try {
             unsubscribe?.();
@@ -219,13 +209,8 @@ async function drivePi(sdk, execution, input, signal, custody) {
     custody?.own({ closed, abort: forceDispose, forceDispose });
     try {
         unsubscribeAgent = agent.subscribe((event) => {
-            if (event.type === "message_end") {
-                const waiter = pendingTells.get(event.message);
-                if (waiter !== undefined) {
-                    pendingTells.delete(event.message);
-                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
-                }
-            }
+            if (event.type === "message_end")
+                tells.accept(event.message);
         });
         unsubscribe = native.subscribe((event) => {
             if (event.type === "agent_end" && !event.willRetry) {
@@ -251,6 +236,9 @@ async function drivePi(sdk, execution, input, signal, custody) {
     await abortable(binding, signal);
     signal.throwIfAborted();
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
+    const sessionModel = piSessionModel(native.model);
+    if (sessionModel !== undefined)
+        events.emit(modelEvent(sessionModel));
     void runPiPrompt(native, input, eventState, state, (result) => {
         void settle(result).catch(() => undefined);
     });
@@ -266,16 +254,14 @@ async function drivePi(sdk, execution, input, signal, custody) {
                 content: [{ type: "text", text: tell.text }],
                 timestamp: new Date().getTime(),
             };
-            return new Promise((resolve, reject) => {
-                pendingTells.set(message, { id: tell.id, resolve });
-                try {
-                    agent.steer(message);
-                }
-                catch (error) {
-                    pendingTells.delete(message);
-                    reject(error);
-                }
-            });
+            const submission = tells.register(message, tell.id);
+            try {
+                agent.steer(message);
+            }
+            catch (error) {
+                tells.fail(message, error);
+            }
+            return submission;
         },
         abort: () => {
             state.abortRequest ??= (async () => {

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

@@ -14,22 +14,24 @@ type ServeClaim = (input: PumpInput & Readonly<{
     claim: RequestEnvelope;
     signal: AbortSignal;
     admissionOpen(): boolean;
-}>) => Promise<boolean>;
+}>) => Promise<void>;
 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;
-    private readonly handled;
     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>;