@astrosheep/keiyaku 4.6.8 → 4.6.9

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/request-lifecycle.d.ts

@@ -14,7 +14,7 @@ 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;
@@ -23,7 +23,6 @@ export declare class BodyRequestPump {
     readonly failure: Promise<never>;
     private readonly closeSignal;
     private readonly executionSignal;
-    private readonly handled;
     private readonly running;
     private readonly cancelBody;
     private admissionClosed;

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

@@ -14,7 +14,6 @@ export class BodyRequestPump {
     failure;
     closeSignal = new AbortController();
     executionSignal = new AbortController();
-    handled = new Set();
     running;
     cancelBody;
     admissionClosed = false;
@@ -54,8 +53,6 @@ export class BodyRequestPump {
                 if (this.closeSignal.signal.aborted)
                     return;
                 const transportId = name.slice(0, -".request.json".length);
-                if (this.handled.has(transportId))
-                    continue;
                 const path = join(this.directory, name);
                 let serialized;
                 try {
@@ -69,11 +66,10 @@ export class BodyRequestPump {
                 const claim = decodeEnvelope(serialized, transportId);
                 if (claim === null) {
                     await rm(path, { force: true });
-                    this.handled.add(transportId);
                     continue;
                 }
                 if (!this.admissionClosed) {
-                    const served = await this.serveClaim({
+                    await this.serveClaim({
                         directory: this.directory,
                         transportId,
                         claim,
@@ -81,10 +77,8 @@ export class BodyRequestPump {
                         signal: this.executionSignal.signal,
                         admissionOpen: () => !this.admissionClosed,
                     });
-                    if (!served)
-                        await rm(path, { force: true });
                 }
-                this.handled.add(transportId);
+                await rm(path, { force: true });
             }
             try {
                 await abortableDelay(POLL_MS, this.closeSignal.signal);

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

@@ -19,15 +19,6 @@ export class AkumaBodyRequestError extends Error {
         this.name = "AkumaBodyRequestError";
     }
 }
-function throwVoidedRequestFailure(action, evidence, failure, decodeFailure, requestId) {
-    const ownerFailure = decodeOwnerFailure(failure, decodeFailure);
-    if (ownerFailure !== null)
-        throw withRequestMetadata(ownerFailure, requestId, action);
-    throw new AkumaBodyRequestError(action, "voided", evidence, requestId);
-}
-function throwUnprovenRequestFailure(action, evidence, requestId, ownerFailure) {
-    throw new AkumaBodyRequestError(action, "unproven", evidence, requestId, ownerFailure === null ? undefined : { cause: ownerFailure });
-}
 function decodeOwnerFailure(failure, decodeFailure) {
     if (failure === undefined || decodeFailure === undefined)
         return null;
@@ -46,59 +37,49 @@ function withRequestMetadata(response, id, action) {
     return response;
 }
 async function readRequestReceipt(input, path, id) {
+    let bytes;
     try {
-        const receipt = decodeReceiptEnvelope(await readFile(path, "utf8"), id, input.command.action);
-        if (receipt === null)
-            throw new Error(`Akuma body request ${id} has an invalid receipt`);
-        if (receipt.state === "refused") {
-            throw new AkumaBodyRequestError(receipt.action, "refused", receipt.diagnostic, receipt.id);
-        }
-        if (receipt.state === "voided" && receipt.outcome !== undefined) {
-            let result;
-            try {
-                result = input.command.decodeResult(receipt.outcome);
-            }
-            catch (error) {
-                throw new Error(`transport integrity: invalid voided live result: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return withRequestMetadata({ kind: "returned", result }, id, input.command.action);
-        }
-        if (receipt.state === "voided") {
-            throwVoidedRequestFailure(receipt.action, receipt.evidence, receipt.failure, input.command.decodeFailure, receipt.id);
-        }
-        if (receipt.state === "unproven") {
-            throwUnprovenRequestFailure(receipt.action, receipt.evidence, receipt.id, decodeOwnerFailure(receipt.failure, input.command.decodeFailure));
-        }
-        if ("reference" in receipt) {
-            let reference;
-            try {
-                reference = input.command.decodeReference(receipt.reference);
-            }
-            catch (error) {
-                const diagnostic = error instanceof Error ? error.message : String(error);
-                throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid durable reference: ${diagnostic}`);
-            }
-            return withRequestMetadata({ kind: "reference", reference }, id, input.command.action);
-        }
-        if (receipt.outcome.kind === "failed") {
-            const failure = receipt.outcome.failure;
-            throw new Error(failure.kind === "failed" ? failure.diagnostic : `Akuma ${failure.id} was not born`);
-        }
-        let result;
-        try {
-            result = input.command.decodeResult(receipt.outcome.result);
-        }
-        catch (error) {
-            const diagnostic = error instanceof Error ? error.message : String(error);
-            throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid live result: ${diagnostic}`);
-        }
-        return withRequestMetadata({ kind: "returned", result }, id, input.command.action);
+        bytes = await readFile(path, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
             return undefined;
         throw error;
     }
+    return decodeRequestReceipt(input.command, bytes, id);
+}
+function decodeRequestReceipt(command, bytes, id) {
+    const receipt = decodeReceiptEnvelope(bytes, id, command.action);
+    if (receipt === null)
+        throw new Error(`Akuma body request ${id} has an invalid receipt`);
+    if (receipt.state === "refused") {
+        throw new AkumaBodyRequestError(receipt.action, "refused", receipt.diagnostic, receipt.id);
+    }
+    if (receipt.state === "unproven" || (receipt.state === "voided" && receipt.outcome === undefined)) {
+        const failure = decodeOwnerFailure(receipt.failure, command.decodeFailure);
+        if (receipt.state === "voided" && failure !== null)
+            throw withRequestMetadata(failure, id, command.action);
+        throw new AkumaBodyRequestError(command.action, receipt.state, receipt.evidence, id, failure === null ? undefined : { cause: failure });
+    }
+    if (receipt.state === "served" && "outcome" in receipt && receipt.outcome.kind === "failed") {
+        const failure = receipt.outcome.failure;
+        throw new Error(failure.kind === "failed" ? failure.diagnostic : `Akuma ${failure.id} was not born`);
+    }
+    const label = "reference" in receipt ? "durable reference" : receipt.state === "voided" ? "voided live result" : "live result";
+    try {
+        if ("reference" in receipt) {
+            return withRequestMetadata({ kind: "reference", reference: command.decodeReference(receipt.reference) }, id, command.action);
+        }
+        const value = receipt.state === "voided"
+            ? receipt.outcome
+            : receipt.outcome.kind === "returned"
+                ? receipt.outcome.result
+                : undefined;
+        return withRequestMetadata({ kind: "returned", result: command.decodeResult(value) }, id, command.action);
+    }
+    catch (error) {
+        throw new Error(`transport integrity: request ${id} action ${command.action} returned an invalid ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 /** Generic rendezvous only: operation owners supply their own request and result codecs. */
 export async function requestBodyCommand(input) {
@@ -126,6 +107,8 @@ export async function requestBodyCommand(input) {
 async function observePublishedRequest(input, id, transportId, path) {
     let observedSequence = 0;
     const consumeProgress = async () => {
+        if (input.onProgress === undefined && input.onProgressGap === undefined)
+            return;
         const snapshot = await readRequestProgress({
             directory: input.directory,
             transportId,

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

@@ -10,7 +10,7 @@ export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     claim: RequestEnvelope;
     admissionOpen(): boolean;
 }>;
-export declare function serveRequest(input: ServeInput): Promise<boolean>;
+export declare function serveRequest(input: ServeInput): Promise<void>;
 export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;
 }

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

@@ -21,33 +21,22 @@ function replayReference(fact, command) {
     }
 }
 async function projectCommandReceipt(input, fact, command, outcome, failure) {
+    const identity = { id: fact.id, action: fact.action };
     const receipt = fact.state === "refused"
-        ? { id: fact.id, action: fact.action, state: "refused", diagnostic: fact.diagnostic }
-        : fact.state === "voided"
+        ? { ...identity, state: fact.state, diagnostic: fact.diagnostic }
+        : fact.state === "voided" || fact.state === "unproven"
             ? {
-                id: fact.id,
-                action: fact.action,
-                state: "voided",
+                ...identity,
+                state: fact.state,
                 evidence: fact.evidence,
                 ...(failure === undefined ? {} : { failure }),
-                ...(outcome === undefined ? {} : { outcome: outcome.result }),
+                ...(fact.state === "voided" && outcome !== undefined ? { outcome: outcome.result } : {}),
             }
-            : fact.state === "unproven"
-                ? {
-                    id: fact.id,
-                    action: fact.action,
-                    state: "unproven",
-                    evidence: fact.evidence,
-                    ...(failure === undefined ? {} : { failure }),
-                }
-                : outcome === undefined
-                    ? {
-                        id: fact.id,
-                        action: fact.action,
-                        state: "served",
-                        reference: replayReference(fact, command),
-                    }
-                    : { id: fact.id, action: fact.action, state: "served", outcome };
+            : {
+                ...identity,
+                state: "served",
+                ...(outcome === undefined ? { reference: replayReference(fact, command) } : { outcome }),
+            };
     try {
         await atomicJson(receiptPath(input.directory, input.transportId), receipt);
     }
@@ -64,51 +53,39 @@ async function serveResolvedCommand(input, command, request, execute) {
         admittedAt: input.now(),
         permitted: request.isPermitted(input.allowed),
     });
-    if (fact.state !== "admitted") {
-        await projectCommandReceipt(input, fact, command);
-        return true;
-    }
-    if (!input.admissionOpen()) {
+    if (fact.state === "admitted" && !input.admissionOpen()) {
         fact = await voidRequest(input.paths, fact.id, "body closed request admission");
+    }
+    if (fact.state !== "admitted") {
         await projectCommandReceipt(input, fact, command);
-        return true;
+        return;
     }
+    const observation = {
+        directory: input.directory,
+        transportId: input.transportId,
+        id: fact.id,
+        action: fact.action,
+    };
+    const progress = publishRequestProgress(observation);
+    const cancellation = command.completion === "service" && request.supportsCancellation
+        ? observeRequestCancellation(observation)
+        : undefined;
+    let outcome;
+    let failure;
     try {
-        const progress = publishRequestProgress({
-            directory: input.directory,
-            transportId: input.transportId,
-            id: fact.id,
-            action: fact.action,
-        });
-        const cancellation = command.completion === "service" && request.supportsCancellation
-            ? observeRequestCancellation({
-                directory: input.directory,
-                transportId: input.transportId,
-                id: fact.id,
-                action: fact.action,
-            })
-            : undefined;
-        const facts = {
+        const served = await execute(fact, {
             id: fact.id,
             admittedAt: fact.admittedAt,
             requester: fact.requester,
             signal: cancellation === undefined ? input.signal : AbortSignal.any([input.signal, cancellation.signal]),
             admissionOpen: input.admissionOpen,
             progress: progress.progress,
-        };
-        try {
-            const served = await execute(fact, facts);
-            fact = served.fact;
-            await progress.flush();
-            await projectCommandReceipt(input, fact, command, served.outcome);
-        }
-        finally {
-            await progress.close();
-            await cancellation?.close();
-        }
+        });
+        fact = served.fact;
+        outcome = served.outcome;
     }
     catch (error) {
-        const failure = encodedFailure(request, error);
+        failure = encodedFailure(request, error);
         const current = await readRequest(input.paths, fact.id);
         if (current === null)
             throw error;
@@ -117,7 +94,7 @@ async function serveResolvedCommand(input, command, request, execute) {
             if (parent === null)
                 throw new Error("reserved request settlement requires a born parent Soul");
             if (!(await settleReserved(input.paths, parent, current, input.now, input.signal)))
-                return true;
+                return;
             fact = (await readRequest(input.paths, fact.id)) ?? current;
         }
         else {
@@ -130,49 +107,45 @@ async function serveResolvedCommand(input, command, request, execute) {
                             : await unproveRequest(input.paths, fact.id, diagnostic(error))
                         : current;
         }
-        await projectCommandReceipt(input, fact, command, undefined, failure);
     }
-    return true;
-}
-async function serveChildCommand(input, command) {
-    const request = command.resolve(input.claim.payload);
-    if (request === null)
-        throw new Error(`registered request action ${input.claim.action} rejected its payload`);
-    return await serveResolvedCommand(input, command, request, async (fact, facts) => {
-        const served = await request.execute(facts);
-        return {
-            fact: await serveChildRequest(input.paths, fact.id, served.child),
-            outcome: { kind: "returned", result: served.result },
-        };
-    });
+    finally {
+        try {
+            await progress.close();
+        }
+        finally {
+            await cancellation?.close();
+        }
+    }
+    // Transport failure cannot re-enter execution settlement.
+    await projectCommandReceipt(input, fact, command, outcome, failure);
 }
-async function serveServiceCommand(input, command) {
-    const request = command.resolve(input.claim.payload);
+async function serveCommand(input, command) {
+    const { completion, request } = command.completion === "child"
+        ? { completion: "child", request: command.resolve(input.claim.payload) }
+        : { completion: "service", request: command.resolve(input.claim.payload) };
     if (request === null)
         throw new Error(`registered request action ${input.claim.action} rejected its payload`);
     return await serveResolvedCommand(input, command, request, async (fact, facts) => {
+        if (completion === "child") {
+            const served = await request.execute(facts);
+            return {
+                fact: await serveChildRequest(input.paths, fact.id, served.child),
+                outcome: { kind: "returned", result: served.result },
+            };
+        }
         await beginRequest(input.paths, fact.id);
         const served = await request.execute(facts);
-        if (served.kind === "voided") {
-            return {
+        return served.kind === "voided"
+            ? {
                 fact: await voidRequest(input.paths, fact.id, "returned owner outcome was voided"),
                 outcome: { kind: "returned", result: served.outcome },
+            }
+            : {
+                fact: await serveUpstreamRequest(input.paths, fact.id, served.serviceJson),
+                outcome: { kind: "returned", result: served.result },
             };
-        }
-        return {
-            fact: await serveUpstreamRequest(input.paths, fact.id, served.serviceJson),
-            outcome: { kind: "returned", result: served.result },
-        };
     });
 }
-async function serveCommand(input, command) {
-    switch (command.completion) {
-        case "child":
-            return await serveChildCommand(input, command);
-        case "service":
-            return await serveServiceCommand(input, command);
-    }
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -190,35 +163,26 @@ function provesNoProductEffect(failure) {
 }
 export async function serveRequest(input) {
     const command = input.commands[input.claim.action];
-    if (command === undefined) {
-        await atomicJson(receiptPath(input.directory, input.transportId), {
-            id: input.claim.id,
-            action: input.claim.action,
-            state: "refused",
-            diagnostic: `request action ${input.claim.action} is not registered`,
-        });
-        return true;
-    }
-    return await serveCommand(input, command);
-}
-async function serveTransportClaim(input) {
-    try {
-        return await serveRequest(input);
-    }
-    catch (error) {
-        if (!isRequestInputConflict(error))
-            throw error;
-        await atomicJson(receiptPath(input.directory, input.transportId), {
-            id: input.claim.id,
-            action: input.claim.action,
-            state: "refused",
-            diagnostic: error.message,
-        });
-        return true;
+    let diagnostic = `request action ${input.claim.action} is not registered`;
+    if (command !== undefined) {
+        try {
+            return await serveCommand(input, command);
+        }
+        catch (error) {
+            if (!isRequestInputConflict(error))
+                throw error;
+            diagnostic = error.message;
+        }
     }
+    await atomicJson(receiptPath(input.directory, input.transportId), {
+        id: input.claim.id,
+        action: input.claim.action,
+        state: "refused",
+        diagnostic,
+    });
 }
 export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveTransportClaim({ ...claim, commands: input.commands })));
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveRequest({ ...claim, commands: input.commands })));
     }
 }