@astrosheep/keiyaku 4.6.8 → 4.6.10

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

@@ -1,5 +1,6 @@
-import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
-import { finiteNumber, object, positiveLine, searchToolCall, trimmed } from "../decode.js";
+import { modelEvent, noteEvent, otherToolCall, unknownEvent, } from "../../provider.js";
+import { finiteNumber, object, observedTextContent, positiveLine, searchToolCall, stringValue, trimmed, } from "../decode.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CLAUDE_MESSAGE_DISPOSITIONS = {
     assistant: "assistant",
     auth_status: "auth",
@@ -124,16 +125,56 @@ function startedPath(name, value) {
 function nonnegativeInt(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
 }
-function fileChange(op, path, gitDiff) {
-    const diff = object(gitDiff);
+function fileChange(op, path, result) {
+    const diff = object(result.gitDiff);
     const added = nonnegativeInt(diff?.additions);
     const removed = nonnegativeInt(diff?.deletions);
-    const diffstat = added === undefined || removed === undefined ? undefined : { added, removed };
+    const patch = stringValue(diff?.patch) ?? structuredPatchText(path, result.structuredPatch);
+    const diffstat = added === undefined || removed === undefined
+        ? patch === undefined
+            ? undefined
+            : diffstatFromUnifiedPatch(patch)
+        : { added, removed };
     return {
         kind: "fileChange",
-        changes: [{ op, path, ...(diffstat === undefined ? {} : { diffstat }) }],
+        changes: [
+            {
+                op,
+                path,
+                ...(diffstat === undefined ? {} : { diffstat }),
+                ...(patch === undefined ? {} : { patch }),
+            },
+        ],
     };
 }
+/**
+ * Render the native hunk record as unified diff text when the provider supplied
+ * no patch of its own. Every figure comes from that record; nothing is
+ * reconstructed from the working tree or from proposed old and new strings.
+ */
+function structuredPatchText(path, value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const hunks = [];
+    for (const entry of value) {
+        const hunk = object(entry);
+        const oldStart = finiteNumber(hunk?.oldStart);
+        const oldLines = finiteNumber(hunk?.oldLines);
+        const newStart = finiteNumber(hunk?.newStart);
+        const newLines = finiteNumber(hunk?.newLines);
+        const lines = hunk?.lines;
+        if (oldStart === undefined ||
+            oldLines === undefined ||
+            newStart === undefined ||
+            newLines === undefined ||
+            !Array.isArray(lines) ||
+            lines.some((line) => typeof line !== "string")) {
+            return undefined;
+        }
+        hunks.push(`@@ -${oldStart},${oldLines} +${newStart},${newLines} @@`, ...lines);
+    }
+    return [`--- a/${path}`, `+++ b/${path}`, ...hunks].join("\n");
+}
 function writeResult(result) {
     const value = object(result);
     if (value === undefined || (value.type !== "create" && value.type !== "update"))
@@ -141,8 +182,7 @@ function writeResult(result) {
     const path = trimmed(value.filePath);
     if (path === undefined)
         return undefined;
-    const op = value.type === "create" ? "add" : "update";
-    return fileChange(op, path, value.gitDiff);
+    return fileChange(value.type === "create" ? "add" : "update", path, value);
 }
 function editResult(result) {
     const value = object(result);
@@ -152,7 +192,7 @@ function editResult(result) {
     if (path === undefined)
         return undefined;
     const status = object(value.gitDiff)?.status;
-    return fileChange(status === "added" ? "add" : "update", path, value.gitDiff);
+    return fileChange(status === "added" ? "add" : "update", path, value);
 }
 function notebookResult(result) {
     const path = trimmed(object(result)?.notebook_path);
@@ -174,6 +214,11 @@ function toolCall(name, input) {
     return (readCall(name, path, value) ?? searchCall(name, value) ?? fileChangeCall(name, path) ?? otherToolCall(name, input));
 }
 function assistantEvents(message, events, state) {
+    // Every complete response names the model that produced it; the native model
+    // identity is reported as-is.
+    const model = trimmed(object(message.message)?.model);
+    if (model !== undefined)
+        events.emit(modelEvent(model));
     if (message.aborted === true)
         return;
     if (message.error !== undefined) {
@@ -216,13 +261,17 @@ function toolResultEvents(message, events, state) {
         state.tools.delete(id);
         const failed = value.is_error === true;
         const structured = failed ? undefined : structuredFileChange(observed.name, message.tool_use_result);
+        const output = observedTextContent(value.content);
         events.emit({
             type: "tool",
             phase: "completed",
             id,
             name: observed.name,
             call: structured ?? observed.call,
-            result: { status: failed ? "error" : "ok" },
+            result: {
+                status: failed ? "error" : "ok",
+                ...(output === undefined ? {} : { output }),
+            },
         });
     }
 }
@@ -234,12 +283,29 @@ function hookResponseNote(value) {
     const exitCode = finiteNumber(value.exit_code);
     return `Hook ${hook} ${outcome}${exitCode === undefined ? "" : ` (exit ${exitCode})`}`;
 }
+/**
+ * Native system notices that prove which model the session is actually using.
+ * `init` reports the startup selection. A refusal fallback reports the model
+ * that serves the retried request; only a session-scoped fallback swaps the
+ * session model, and `local` leaves it unchanged. The two no-longer-emitted
+ * directions stay in the native enum and are never treated as evidence.
+ */
+function systemModelEvidence(subtype, value) {
+    if (subtype === "init")
+        return trimmed(value.model);
+    if (subtype !== "model_refusal_fallback" || value.scope === "local")
+        return undefined;
+    return value.direction === "revert" || value.direction === "sticky" ? undefined : trimmed(value.fallback_model);
+}
 function emitSystemMessage(value, events) {
     const subtype = trimmed(value?.subtype) ?? "unknown";
     if (!Object.hasOwn(CLAUDE_SYSTEM_DISPOSITIONS, subtype)) {
         events.emit(unknownEvent(subtype));
         return;
     }
+    const evidence = systemModelEvidence(subtype, value);
+    if (evidence !== undefined)
+        events.emit(modelEvent(evidence));
     const systemDisposition = CLAUDE_SYSTEM_DISPOSITIONS[subtype];
     if (systemDisposition === "drop")
         return;

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

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { providerLifecycle } from "../lifecycle.js";
 import { emitClaudeMessage } from "./events.js";
@@ -98,9 +98,6 @@ async function forkClaude(load, execution, input) {
         throw new Error("Claude fork reused the source session id");
     return { session: { sessionId: forked.sessionId } };
 }
-function launchText(input) {
-    return [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
-}
 function successfulResult(message, historyId) {
     return {
         kind: "answered",
@@ -292,7 +289,7 @@ async function driveClaude(load, execution, drive, custody) {
     const run = randomUUID();
     const accepted = [];
     const driveState = { submission: 0, openSubmissions: 0 };
-    const launchAcknowledged = input.push(claudeUserMessage(launchText(drive)));
+    const launchAcknowledged = input.push(claudeUserMessage(launchPrompt(drive.body, drive.launchTells)));
     const query = sdk.query({
         prompt: input.iterable,
         options: claudeQueryOptions(drive, execution, abortController),

package/build/src/akuma/providers/codex-app-server/events.js

@@ -1,4 +1,5 @@
-import { noteEvent, unknownEvent, } from "../../provider.js";
+import { modelEvent, noteEvent, unknownEvent, } from "../../provider.js";
+import { stringValue } from "../decode.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CODEX_NOTIFICATION_DISPOSITIONS = {
     "account/login/completed": "drop",
@@ -148,12 +149,14 @@ function itemChanges(item) {
         const op = fileChangeOp(change?.kind);
         if (path === undefined || op === undefined)
             return [];
-        const diffstat = typeof change?.diff === "string" ? diffstatFromUnifiedPatch(change.diff) : undefined;
+        const patch = stringValue(change?.diff);
+        const diffstat = patch === undefined ? undefined : diffstatFromUnifiedPatch(patch);
         return [
             {
                 op,
                 path,
                 ...(diffstat === undefined ? {} : { diffstat }),
+                ...(patch === undefined ? {} : { patch }),
             },
         ];
     });
@@ -195,10 +198,12 @@ function itemToolResult(item) {
     const status = codexText(item.status);
     const failed = error !== undefined || status === "failed" || status === "error";
     const detail = codexText(error?.message) ?? codexText(error?.additionalDetails);
+    const output = stringValue(item.aggregatedOutput);
     const exitCode = typeof item.exitCode === "number" && Number.isSafeInteger(item.exitCode) ? item.exitCode : undefined;
     return {
         status: failed || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
         ...(detail === undefined ? {} : { message: detail }),
+        ...(output === undefined ? {} : { output }),
         ...(exitCode === undefined ? {} : { exitCode }),
     };
 }
@@ -318,6 +323,13 @@ function hookCompletionNote(params) {
     const diagnostic = codexText(run?.statusMessage) ?? codexText(issue?.text);
     return `Hook ${eventName} ${label}${diagnostic === undefined ? "" : `: ${diagnostic}`}`;
 }
+/**
+ * A reroute names the model that now serves this thread, so it is runtime-model
+ * evidence as well as narration. Other notifications carry no model identity.
+ */
+function notificationModel(method, params) {
+    return method === "model/rerouted" ? codexText(params.toModel) : undefined;
+}
 function observeError(params, state, events) {
     const detail = turnError(params.error) ?? codexText(params.message) ?? "codex app-server error";
     state.error = detail;
@@ -348,6 +360,9 @@ export function codexNotificationResult(notification, state, events) {
         return undefined;
     }
     const disposition = CODEX_NOTIFICATION_DISPOSITIONS[method];
+    const rerouted = notificationModel(method, params);
+    if (rerouted !== undefined)
+        events.emit(modelEvent(rerouted));
     switch (disposition) {
         case "drop":
             return undefined;

package/build/src/akuma/providers/codex-app-server/index.js

@@ -1,5 +1,5 @@
 import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
-import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { providerLifecycle } from "../lifecycle.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
@@ -30,6 +30,12 @@ function turnId(result) {
         throw new Error("codex app-server did not return a turn id");
     return id;
 }
+/** Thread admission answers with the model the server actually loaded. */
+function emitAdmittedModel(result, events) {
+    const model = codexText(codexObject(result)?.model);
+    if (model !== undefined)
+        events.emit(modelEvent(model));
+}
 async function steerTurn(server, state, tell) {
     if (state.settled)
         return { kind: "turn-ended" };
@@ -62,13 +68,15 @@ async function admitTurn(server, input, state, events, config) {
                 : { developerInstructions: input.options.systemPrompt }),
     };
     if (input.session.kind === "fresh") {
-        state.threadId = threadId(await server.request("thread/start", threadParams));
+        const admitted = await server.request("thread/start", threadParams);
+        state.threadId = threadId(admitted);
+        emitAdmittedModel(admitted, events);
     }
     else {
-        state.threadId = threadId(await server.request("thread/resume", {
-            threadId: input.session.coordinate.sessionId,
-            ...threadParams,
-        }), input.session.coordinate.sessionId);
+        const resumed = input.session.coordinate.sessionId;
+        const admitted = await server.request("thread/resume", { threadId: resumed, ...threadParams });
+        state.threadId = threadId(admitted, resumed);
+        emitAdmittedModel(admitted, events);
     }
     events.emit({ type: "session", coordinate: { sessionId: state.threadId } });
     state.turnId = turnId(await server.request("turn/start", {
@@ -76,9 +84,7 @@ async function admitTurn(server, input, state, events, config) {
         input: [
             {
                 type: "text",
-                text: [input.body, ...input.launchTells.map((tell) => tell.text)]
-                    .filter((part) => part.length > 0)
-                    .join("\n\n"),
+                text: launchPrompt(input.body, input.launchTells),
             },
         ],
         ...(input.options.model === undefined ? {} : { model: input.options.model }),

package/build/src/akuma/providers/decode.d.ts

@@ -12,6 +12,14 @@ export declare function nonblank(value: unknown): string | undefined;
 export declare function trimmed(value: unknown): string | undefined;
 /** A nonempty string, returned as supplied; internal whitespace stays content. */
 export declare function text(value: unknown): string | undefined;
+/** Any string, including the empty one; absence stays absence. */
+export declare function stringValue(value: unknown): string | undefined;
+/**
+ * The observed text of one native result value: a plain string, or its text
+ * blocks joined in native order. A value carrying no text block observed no
+ * text, while a present empty string is observed and empty.
+ */
+export declare function observedTextContent(content: unknown): string | undefined;
 /** A one-based line number. */
 export declare function positiveLine(value: unknown): number | undefined;
 export declare function nonnegativeCount(value: unknown): number | undefined;

package/build/src/akuma/providers/decode.js

@@ -22,6 +22,27 @@ export function trimmed(value) {
 export function text(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+/** Any string, including the empty one; absence stays absence. */
+export function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/**
+ * The observed text of one native result value: a plain string, or its text
+ * blocks joined in native order. A value carrying no text block observed no
+ * text, while a present empty string is observed and empty.
+ */
+export function observedTextContent(content) {
+    const single = stringValue(content);
+    if (single !== undefined)
+        return single;
+    if (!Array.isArray(content))
+        return undefined;
+    const blocks = content.flatMap((block) => {
+        const value = object(block);
+        return value?.type === "text" && typeof value.text === "string" ? [value.text] : [];
+    });
+    return blocks.length === 0 ? undefined : blocks.join("");
+}
 /** A one-based line number. */
 export function positiveLine(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;

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

@@ -1,3 +1,4 @@
+import { tellRegistry } from "../../provider.js";
 import { nonblank, object, searchToolCall } from "../decode.js";
 import { providerLifecycle } from "../lifecycle.js";
 import { startAcpSession, } from "../acp/core.js";
@@ -94,18 +95,13 @@ function argv(execution, options) {
     values.push("stdio");
     return values;
 }
-function withInterject(live, pending) {
+function withInterject(live, tells) {
     return {
         ...live.session,
         tell: (tell) => {
             if (!live.open())
                 return Promise.resolve({ kind: "turn-ended" });
-            const existing = pending.get(tell.id);
-            if (existing !== undefined)
-                throw new Error("Grok Build duplicate pending interjection id");
-            const receipt = new Promise((resolve, reject) => {
-                pending.set(tell.id, { resolve, reject });
-            });
+            const receipt = tells.register(tell.id, tell.id);
             void live.agent
                 .request(INTERJECT_METHOD, {
                 sessionId: live.sessionId,
@@ -113,14 +109,10 @@ function withInterject(live, pending) {
                 interjectionId: tell.id,
             })
                 .then((response) => {
-                if (response?.status !== "queued" && pending.has(tell.id)) {
-                    pending.get(tell.id)?.reject(new Error("Grok Build interject did not return queued"));
-                    pending.delete(tell.id);
+                if (response?.status !== "queued") {
+                    tells.fail(tell.id, new Error("Grok Build interject did not return queued"));
                 }
-            }, (error) => {
-                pending.get(tell.id)?.reject(error);
-                pending.delete(tell.id);
-            });
+            }, (error) => tells.fail(tell.id, error));
             return receipt;
         },
     };
@@ -129,7 +121,7 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
     if (execution.executable === undefined)
         throw new TypeError("Grok Build provider execution requires executable");
     const drive = async (input, custody) => {
-        const pending = new Map();
+        const tells = tellRegistry();
         let live;
         const launch = {
             argv: argv(execution, input.options),
@@ -142,23 +134,15 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
                 client.onNotification(INTERJECTION_METHOD, (value) => value, ({ params }) => {
                     if (params.sessionId !== live?.sessionId)
                         return;
-                    const waiter = pending.get(params.interjectionId);
-                    if (waiter === undefined)
-                        return;
-                    pending.delete(params.interjectionId);
-                    waiter.resolve({ kind: "accepted", fence: params.interjectionId });
+                    tells.accept(params.interjectionId);
                 });
             },
-            onTerminal: () => {
-                for (const waiter of pending.values())
-                    waiter.resolve({ kind: "turn-ended" });
-                pending.clear();
-            },
+            onTerminal: () => tells.end(),
             interpretTool: interpretGrokTool,
             freshSessionMeta: { ...(dependencies.freshSessionMeta ?? {}), ...(sessionMeta.freshSessionMeta ?? {}) },
             loadSessionMeta: { ...(dependencies.loadSessionMeta ?? {}), ...(sessionMeta.loadSessionMeta ?? {}) },
         }, custody);
-        return withInterject(live, pending);
+        return withInterject(live, tells);
     };
     return {
         admitOptions: optionAdmission,

package/build/src/akuma/providers/opencode-sdk/event-stream.d.ts

@@ -2,8 +2,8 @@ import type { AttemptCustody } from "../../provider.js";
 import type { OpencodeEventSubscriptionRequest } from "./session.js";
 /**
  * One adapter-private owner for every resource an OpenCode event subscription
- * creates: the native subscription, its fetch and reader, the pending read, and
- * the SDK's retry waiting. `closed` resolves only after those resources really
+ * creates: the native subscription, its fetch and reader, and the pending read.
+ * `closed` resolves only after those resources really
  * retired; a teardown rejection escapes through it, and an unprovable
  * retirement leaves it pending so existing custody reports the attempt hung.
  */
@@ -14,7 +14,7 @@ export type OwnedEventStream = Readonly<{
     next(): Promise<IteratorResult<unknown>>;
     /** Aborts the owned signal, settles any pending read, then awaits real iterator retirement. */
     retire(): Promise<void>;
-    /** Resolves only when subscription, reader, and retry waiting actually ended. */
+    /** Resolves only when subscription and reader actually ended. */
     closed: Promise<void>;
 }>;
 export declare function ownEventStream(input: Readonly<{

package/build/src/akuma/providers/opencode-sdk/event-stream.js

@@ -1,25 +1,3 @@
-/**
- * A backoff sleep that resolves when the owned signal aborts and always clears
- * its timer. Cancellation before the sleep starts completes immediately, and a
- * simultaneous timeout and abort still settles once and drops the listener.
- */
-function cancellableSleep(signal) {
-    return (milliseconds) => new Promise((resolve) => {
-        if (signal.aborted) {
-            resolve();
-            return;
-        }
-        let timer;
-        const finish = () => {
-            if (timer !== undefined)
-                clearTimeout(timer);
-            signal.removeEventListener("abort", finish);
-            resolve();
-        };
-        timer = setTimeout(finish, milliseconds);
-        signal.addEventListener("abort", finish, { once: true });
-    });
-}
 export function ownEventStream(input) {
     const controller = new AbortController();
     const follow = () => {
@@ -49,8 +27,8 @@ export function ownEventStream(input) {
         if (settling !== undefined)
             return settling;
         settling = (async () => {
-            // Abort first: it interrupts the SDK's fetch, reader, and backoff and
-            // settles a pending read, before iterator return can be waited on.
+            // Abort first: it interrupts the SDK's fetch and reader and settles a
+            // pending read before iterator return can be waited on.
             if (!controller.signal.aborted)
                 controller.abort(new Error("OpenCode event stream retired"));
             input.signal.removeEventListener("abort", follow);
@@ -72,7 +50,6 @@ export function ownEventStream(input) {
         const subscription = await input.subscribe({
             directory: input.directory,
             signal: controller.signal,
-            sleep: cancellableSleep(controller.signal),
         });
         iterator = subscription.stream[Symbol.asyncIterator]();
     })();

package/build/src/akuma/providers/opencode-sdk/events.d.ts

@@ -2,52 +2,16 @@ import { type AgentEvent, type ToolCall } from "../../provider.js";
 type Emitter = {
     emit(event: AgentEvent): void;
 };
-type ObservedTool = Readonly<{
-    name: string;
-    call: ToolCall;
-}>;
 type State = {
     sessionId?: string;
-    assistantParts: Set<string>;
-    reasoningParts: Set<string>;
-    tools: Map<string, ObservedTool>;
-    completedTools: Set<string>;
-    failure?: string;
-};
-export declare const OPENCODE_EVENT_DISPOSITIONS: {
-    readonly "server.instance.disposed": "dropped";
-    readonly "installation.updated": "dropped";
-    readonly "installation.update-available": "dropped";
-    readonly "lsp.client.diagnostics": "dropped";
-    readonly "lsp.updated": "dropped";
-    readonly "message.updated": "mapped";
-    readonly "message.removed": "dropped";
-    readonly "message.part.updated": "mapped";
-    readonly "message.part.removed": "dropped";
-    readonly "permission.updated": "dropped";
-    readonly "permission.replied": "dropped";
-    readonly "session.status": "dropped";
-    readonly "session.idle": "dropped";
-    readonly "session.compacted": "note";
-    readonly "file.edited": "dropped";
-    readonly "todo.updated": "mapped";
-    readonly "command.executed": "dropped";
-    readonly "session.created": "dropped";
-    readonly "session.updated": "dropped";
-    readonly "session.deleted": "dropped";
-    readonly "session.diff": "dropped";
-    readonly "session.error": "mapped";
-    readonly "file.watcher.updated": "dropped";
-    readonly "vcs.branch.updated": "dropped";
-    readonly "tui.prompt.append": "dropped";
-    readonly "tui.command.execute": "dropped";
-    readonly "tui.toast.show": "dropped";
-    readonly "pty.created": "dropped";
-    readonly "pty.updated": "dropped";
-    readonly "pty.exited": "dropped";
-    readonly "pty.deleted": "dropped";
-    readonly "server.connected": "dropped";
+    tools: Map<string, {
+        name: string;
+        call?: ToolCall;
+    }>;
+    completed: Set<string>;
 };
+export declare function diagnostic(value: unknown): string;
+/** Only complete native values enter narration. The caller enforces submission/step correlation. */
 export declare function mapEvent(value: unknown, events: Emitter, state: State): void;
 export declare function createEventState(sessionId?: string): State;
 export {};