@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -0,0 +1,65 @@
+/**
+ * Native payload decoders shared by provider event adaptation. Every adapter
+ * reads the same untrusted native shapes; these are the only places that decide
+ * what a present value means, so each keeps one exact predicate and return.
+ */
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function object(value) {
+    return isRecord(value) ? value : undefined;
+}
+/** A string with non-blank trim, returned as supplied. */
+export function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+/** A string with non-blank trim, returned trimmed. */
+export function trimmed(value) {
+    const text = nonblank(value);
+    return text === undefined ? undefined : text.trim();
+}
+/** A nonempty string, returned as supplied; internal whitespace stays content. */
+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;
+}
+export function nonnegativeCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+export function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** One neutral search call carrying only the bounds the native input supplied. */
+export function searchToolCall(query, scope, bounds = {}) {
+    return {
+        kind: "search",
+        query,
+        ...(scope === undefined ? {} : { scope }),
+        ...(bounds.path === undefined ? {} : { path: bounds.path }),
+        ...(bounds.glob === undefined ? {} : { glob: bounds.glob }),
+    };
+}

package/build/src/akuma/providers/execution-environment.d.ts

@@ -1,5 +1,6 @@
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
-declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDECODE", "CODEX_THREAD_ID", "OPENCODE_SESSION_ID", "PI_SESSION_ID", "PI_SESSION_FILE", "PASEO_AGENT_ID", "SQUARE_PARTICIPANT_NAME"];
+export declare const AKUMA_REQUESTS_ENTRY_ENV = "AKUMA_REQUESTS_ENTRY";
+declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDECODE", "CODEX_THREAD_ID", "OPENCODE_SESSION_ID", "PI_SESSION_ID", "PI_SESSION_FILE", "PASEO_AGENT_ID", "SQUARE_PARTICIPANT_NAME", "KEIYAKU_EXTERNAL_CALLER"];
 type Environment = Readonly<Record<string, string | undefined>>;
 /** Construct the environment for one isolated Akuma execution or native child. */
 export declare function akumaExecutionEnvironment(inherited: Environment, overrides?: Environment, requests?: string, nativeIdentity?: readonly (typeof PARENT_HARNESS_IDENTITY_KEYS)[number][]): Record<string, string>;

package/build/src/akuma/providers/execution-environment.js

@@ -1,4 +1,5 @@
 export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+export const AKUMA_REQUESTS_ENTRY_ENV = "AKUMA_REQUESTS_ENTRY";
 const PARENT_HARNESS_IDENTITY_KEYS = [
     "CLAUDE_CODE_SESSION_ID",
     "CLAUDE_CODE_CHILD_SESSION",
@@ -9,6 +10,7 @@ const PARENT_HARNESS_IDENTITY_KEYS = [
     "PI_SESSION_FILE",
     "PASEO_AGENT_ID",
     "SQUARE_PARTICIPANT_NAME",
+    "KEIYAKU_EXTERNAL_CALLER",
 ];
 /** Construct the environment for one isolated Akuma execution or native child. */
 export function akumaExecutionEnvironment(inherited, overrides = {}, requests, nativeIdentity = []) {
@@ -18,6 +20,7 @@ export function akumaExecutionEnvironment(inherited, overrides = {}, requests, n
         delete environment[key];
     Object.assign(environment, preserved);
     delete environment[AKUMA_REQUESTS_ENV];
+    delete environment[AKUMA_REQUESTS_ENTRY_ENV];
     if (requests !== undefined)
         environment[AKUMA_REQUESTS_ENV] = requests;
     return environment;

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

@@ -1,15 +1,9 @@
-import { createProviderAttempt } from "../../provider.js";
+import { tellRegistry } from "../../provider.js";
+import { nonblank, object, searchToolCall } from "../decode.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { startAcpSession, } from "../acp/core.js";
 const INTERJECT_METHOD = "_x.ai/interject";
 const INTERJECTION_METHOD = "_x.ai/session/interjection";
-function nonblank(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
 function nativeName(update) {
     const wire = update;
     return nonblank(update.name) ?? nonblank(update.title) ?? nonblank(wire.toolName);
@@ -26,17 +20,9 @@ function contentSearchCall(name, input) {
     if (name !== "grep" && name !== "hashline_grep")
         return undefined;
     const query = nonblank(input.pattern);
-    if (query === undefined)
-        return undefined;
-    const path = nonblank(input.path);
-    const glob = nonblank(input.glob);
-    return {
-        kind: "search",
-        query,
-        scope: "content",
-        ...(path === undefined ? {} : { path }),
-        ...(glob === undefined ? {} : { glob }),
-    };
+    return query === undefined
+        ? undefined
+        : searchToolCall(query, "content", { path: nonblank(input.path), glob: nonblank(input.glob) });
 }
 function runCall(name, input) {
     if (name !== "run_terminal_cmd")
@@ -109,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,
@@ -128,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;
         },
     };
@@ -144,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),
@@ -157,27 +134,18 @@ 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,
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle(drive),
     };
 }

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

@@ -14,6 +14,8 @@ async function adapterFor(execution) {
         return (await import("./grok-build/index.js")).createGrokBuildProvider(execution);
     if (execution.kind === "opencode-sdk")
         return (await import("./opencode-sdk/index.js")).createOpencodeProvider(execution);
+    if (execution.kind === "paseo")
+        return (await import("./paseo/index.js")).createPaseoProvider(execution);
     if (execution.kind === "pi")
         return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);

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

@@ -0,0 +1,9 @@
+import { type AttemptCustody, type ProviderAdapter, type Session } from "../provider.js";
+type DriveInput = Parameters<ProviderAdapter["start"]>[0] | Parameters<NonNullable<ProviderAdapter["resume"]>>[0];
+/**
+ * Start and resume share one custody descriptor: each creates one attempt whose
+ * own controller signal reaches the adapter, and the caller's signal stays a
+ * cancellation notification.
+ */
+export declare function providerLifecycle(drive: (input: DriveInput, custody: AttemptCustody) => Promise<Session>): Pick<ProviderAdapter, "start" | "resume">;
+export {};

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

@@ -0,0 +1,10 @@
+import { createProviderAttempt } from "../provider.js";
+/**
+ * Start and resume share one custody descriptor: each creates one attempt whose
+ * own controller signal reaches the adapter, and the caller's signal stays a
+ * cancellation notification.
+ */
+export function providerLifecycle(drive) {
+    const attempt = (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody));
+    return { start: attempt, resume: attempt };
+}

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 {};