@astrosheep/keiyaku 4.5.16 → 4.5.17

package/build/src/akuma/body.js

@@ -219,6 +219,34 @@ function turnOutcomeEmitter(launch, soul) {
         })();
     };
 }
+function bodyEndEmitter(launch, soul) {
+    let plugins;
+    const reportDiagnostic = (message) => {
+        void recordPluginDiagnostic(launch.paths, "body end", message);
+    };
+    return (bodySequence, end, diagnostic) => {
+        void (async () => {
+            try {
+                plugins ??= pluginRuntime({
+                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
+                    reportDiagnostic,
+                });
+                const runtime = await plugins;
+                await runtime.emit({
+                    kind: "akuma.body-ended",
+                    akumaId: soul.id,
+                    bodySequence,
+                    end,
+                    ...(diagnostic === undefined ? {} : { diagnostic }),
+                    ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
+                }, reportDiagnostic);
+            }
+            catch (error) {
+                await recordPluginDiagnostic(launch.paths, "body end", error);
+            }
+        })();
+    };
+}
 async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime } = input;
     let initial = launch.initialBody;
@@ -393,10 +421,12 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     let pendingTellDisposition = undefined;
     let bodySequence;
     let decidedDisposition = null;
+    let emitBodyEnd;
     try {
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
+        emitBodyEnd = bodyEndEmitter(launch, soul);
         if (launch.seed === undefined && launch.initialBody === undefined) {
             const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
             if (heart.pending.length === 0 && requests.length === 0)
@@ -447,6 +477,12 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
                 at: runtime.now(),
                 handoff: pendingTellDisposition === "handoff",
             });
+            const finalBody = (await readHeart(launch.paths)).latestBody;
+            if (emitBodyEnd !== undefined &&
+                finalBody?.sequence === bodySequence &&
+                (finalBody.end !== undefined || finalBody.hung !== undefined)) {
+                emitBodyEnd(bodySequence, finalBody.hung === undefined ? finalBody.end : "hung", finalBody.hung?.diagnostic);
+            }
         }
         leash.release();
         if (decidedDisposition !== null) {

package/build/src/akuma/providers/grok-build/index.js

@@ -87,14 +87,21 @@ function optionAdmission(options) {
     };
 }
 function grokSessionMeta(config, options) {
-    const configured = config === undefined ? {} : { freshSessionMeta: config, loadSessionMeta: config };
+    // Keiyaku does not implement Grok's reverse ask_user_question request, so
+    // keep that unsupported tool out of every session's advertised toolset.
+    const sessionMeta = { ...(config ?? {}), askUserQuestion: false };
+    const configured = { freshSessionMeta: sessionMeta, loadSessionMeta: sessionMeta };
     if (options.systemPrompt === undefined || options.systemPrompt.length === 0)
         return configured;
     if (options.systemPromptMode === "append")
-        return { ...configured, freshSessionMeta: { ...config, rules: options.systemPrompt } };
+        return { ...configured, freshSessionMeta: { ...sessionMeta, rules: options.systemPrompt } };
     if (options.systemPromptMode === "replace") {
         const meta = { systemPromptOverride: options.systemPrompt };
-        return { ...configured, freshSessionMeta: { ...config, ...meta }, loadSessionMeta: { ...config, ...meta } };
+        return {
+            ...configured,
+            freshSessionMeta: { ...sessionMeta, ...meta },
+            loadSessionMeta: { ...sessionMeta, ...meta },
+        };
     }
     return configured;
 }
@@ -137,10 +144,12 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
         };
+        const sessionMeta = grokSessionMeta(execution.config, input.options);
         return withInterject(await startAcpSession(launch, input, {
             ...dependencies,
             interpretTool: interpretGrokTool,
-            ...grokSessionMeta(execution.config, input.options),
+            freshSessionMeta: { ...(dependencies.freshSessionMeta ?? {}), ...(sessionMeta.freshSessionMeta ?? {}) },
+            loadSessionMeta: { ...(dependencies.loadSessionMeta ?? {}), ...(sessionMeta.loadSessionMeta ?? {}) },
         }, custody));
     };
     return {

package/build/src/index.d.ts

@@ -2,5 +2,5 @@ export * from "./library/keiyaku.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";
-export type { KeiyakuPlugin, PluginContext, PluginHooks, PluginInstance, PluginManifest, PluginOutcome, PluginSignal, PluginSignalMap, } from "./plugin/public.js";
+export type { KeiyakuPlugin, PluginContext, PluginHooks, PluginInstance, PluginManifest, PluginBodyEnd, PluginOutcome, PluginSignal, PluginSignalMap, } from "./plugin/public.js";
 export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";

package/build/src/plugin/public.d.ts

@@ -14,6 +14,7 @@ export type PluginOutcome = Readonly<{
     kind: "failed";
     reason: string;
 }>;
+export type PluginBodyEnd = "exited" | "broke-off" | "put-down" | "hung";
 export type PluginSignalMap = Readonly<{
     "akuma.called": Readonly<{
         akumaId: string;
@@ -26,6 +27,13 @@ export type PluginSignalMap = Readonly<{
         outcome: PluginOutcome;
         contractId?: string;
     }>;
+    "akuma.body-ended": Readonly<{
+        akumaId: string;
+        bodySequence: number;
+        end: PluginBodyEnd;
+        diagnostic?: string;
+        contractId?: string;
+    }>;
 }>;
 export type PluginSignal = {
     [K in keyof PluginSignalMap]: Readonly<{

package/build/src/plugin/runtime.js

@@ -170,7 +170,7 @@ function handlers(pluginId, instance) {
         throw new TypeError("plugin signals must be an object");
     const registered = [];
     for (const [kind, handler] of Object.entries(instance.signals)) {
-        if (kind !== "akuma.called" && kind !== "akuma.turn-outcome") {
+        if (kind !== "akuma.called" && kind !== "akuma.turn-outcome" && kind !== "akuma.body-ended") {
             throw new TypeError(`plugin signal is unknown: ${kind}`);
         }
         if (typeof handler !== "function")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.16",
+  "version": "4.5.17",
   "workspaces": [
     "plugins/*"
   ],