@astrosheep/keiyaku 4.6.6 → 4.6.8

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

@@ -1,6 +1,7 @@
 import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
 import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 function diagnostic(error) {
@@ -214,7 +215,6 @@ export function createCodexAppServerProvider(input = "codex") {
             };
         },
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => await forkCodex(execution, input, custody)),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle((input, custody) => startCodex(execution, input, custody)),
     };
 }

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

@@ -0,0 +1,25 @@
+import type { SearchScope, ToolCall } from "../provider.js";
+/**
+ * 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 declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+export declare function object(value: unknown): Readonly<Record<string, unknown>> | undefined;
+/** A string with non-blank trim, returned as supplied. */
+export declare function nonblank(value: unknown): string | undefined;
+/** A string with non-blank trim, returned trimmed. */
+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;
+/** A one-based line number. */
+export declare function positiveLine(value: unknown): number | undefined;
+export declare function nonnegativeCount(value: unknown): number | undefined;
+export declare function finiteNumber(value: unknown): number | undefined;
+/** One neutral search call carrying only the bounds the native input supplied. */
+export declare function searchToolCall(query: string, scope: SearchScope | undefined, bounds?: Readonly<{
+    path?: string | undefined;
+    glob?: string | undefined;
+}>): Extract<ToolCall, {
+    kind: "search";
+}>;

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

@@ -0,0 +1,44 @@
+/**
+ * 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;
+}
+/** 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,8 @@
-import { createProviderAttempt } 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 +19,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")
@@ -177,7 +162,6 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
     };
     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/events.js

@@ -1,4 +1,5 @@
 import { noteEvent, otherToolCall } from "../../provider.js";
+import { nonnegativeCount, object, positiveLine, text } from "../decode.js";
 export const OPENCODE_EVENT_DISPOSITIONS = {
     "server.instance.disposed": "dropped",
     "installation.updated": "dropped",
@@ -44,25 +45,11 @@ const RUNTIME_DROPPED_EVENT_KINDS = new Set([
     "server.heartbeat",
     "message.part.delta",
 ]);
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function text(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
 function diagnostic(value) {
     const data = object(value);
     const nested = object(data?.data);
     return text(nested?.message) ?? text(data?.message) ?? "OpenCode session failed";
 }
-function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
-function nonnegativeCount(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
 function diffstat(value) {
     if (value === undefined)
         return undefined;

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,19 +1,13 @@
 import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { nonblank, object } from "../decode.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { ownEventStream } from "./event-stream.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, messageId, OPENCODE_SDK_PROVIDER, parseModel, } from "./session.js";
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function text(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
 function diagnostic(error) {
     const value = object(error);
     const nested = object(value?.data);
-    return text(nested?.message) ?? text(value?.message) ?? String(error);
+    return nonblank(nested?.message) ?? nonblank(value?.message) ?? String(error);
 }
 function opencodeSessionId(coordinateValue) {
     if (!("sessionId" in coordinateValue) || coordinateValue.sessionId === undefined) {
@@ -84,9 +78,9 @@ async function readTurnResult(input) {
         const user = rows.find((row) => row.info.role === "user" && row.info.id === input.messageID);
         if (user === undefined)
             return { kind: "failed", diagnostic: "OpenCode completed without the admitted user message" };
-        const userId = text(user.info.id);
+        const userId = nonblank(user.info.id);
         const assistant = newest(rows.filter((row) => row.info.role === "assistant" && row.info.parentID === userId && row.info.summary !== true));
-        const historyId = text(assistant?.info.id);
+        const historyId = nonblank(assistant?.info.id);
         if (input.state.failure !== undefined)
             return { kind: "failed", diagnostic: input.state.failure };
         if (assistant === undefined)
@@ -108,12 +102,12 @@ async function readTurnResult(input) {
 function nativeSessionId(value) {
     const event = object(value);
     const properties = object(event?.properties);
-    const direct = text(properties?.sessionID);
+    const direct = nonblank(properties?.sessionID);
     if (direct !== undefined)
         return direct;
     const info = object(properties?.info);
     const part = object(properties?.part);
-    return text(info?.sessionID) ?? text(part?.sessionID);
+    return nonblank(info?.sessionID) ?? nonblank(part?.sessionID);
 }
 function scopedProperties(value, sessionId) {
     const properties = object(object(value)?.properties);
@@ -328,7 +322,7 @@ async function openDriveSession(runtime, input, resumeSessionId, signal) {
         : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }));
     signal.throwIfAborted();
     const info = object(object(response)?.data) ?? object(response);
-    const sessionId = text(info?.id) ?? resumeSessionId;
+    const sessionId = nonblank(info?.id) ?? resumeSessionId;
     if (sessionId === undefined)
         throw new Error("OpenCode did not return a session id");
     return { session, sessionId };
@@ -465,8 +459,7 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                 options: Object.freeze({ ...options }),
             };
         },
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
+        ...providerLifecycle((input, custody) => drive(execution, input, loader, custody)),
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const sessionId = opencodeSessionId(input.session);
             let close;
@@ -500,7 +493,7 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                     body: { messageID: input.at },
                 });
                 const info = object(object(result)?.data) ?? object(result);
-                const id = text(info?.id);
+                const id = nonblank(info?.id);
                 if (id === undefined || id === sessionId)
                     throw new Error("OpenCode fork returned an invalid session id");
                 return { session: coordinate(id) };

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -3,6 +3,7 @@ import { randomBytes } from "node:crypto";
 import { abortable } from "../../abort.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
+import { isRecord } from "../decode.js";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
 /**
  * Adapt the installed client's generated event endpoint to the adapter's
@@ -60,9 +61,6 @@ const HEADLESS_PERMISSION_BASE = Object.freeze({
     read: "allow",
     question: "deny",
 });
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 /**
  * Compose the config handed to a headless opencode server. The permission base
  * layer fills only the classes the caller leaves unspecified: an explicit caller

package/build/src/akuma/providers/paseo/events.d.ts

@@ -0,0 +1,25 @@
+import type { AgentStreamEventPayload } from "@getpaseo/protocol/messages";
+import { AgentEventChannel, type TurnResult } from "../../provider.js";
+/** Live fragments belong to a canonical admitted turn, not agent-wide status. */
+export declare class PaseoTurn {
+    readonly messageId: string;
+    readonly events: AgentEventChannel;
+    readonly admission: Promise<string>;
+    readonly completion: Promise<TurnResult>;
+    private admit;
+    private rejectAdmission;
+    private finish;
+    private rejectCompletion;
+    private turnId;
+    private readonly messages;
+    private readonly messagesById;
+    private readonly calls;
+    private answer;
+    private assistantContiguous;
+    settled: boolean;
+    terminal: boolean;
+    constructor(messageId: string);
+    receive(event: AgentStreamEventPayload): void;
+    private appendAssistant;
+    fail(error: unknown): void;
+}

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

@@ -0,0 +1,157 @@
+import { AgentEventChannel, otherToolCall } from "../../provider.js";
+function toolCall(item) {
+    const detail = item.detail;
+    switch (detail.type) {
+        case "shell":
+            return { kind: "run", command: detail.command };
+        case "read":
+            return {
+                kind: "read",
+                path: detail.filePath,
+                ...(detail.offset === undefined ? {} : { offset: detail.offset }),
+                ...(detail.limit === undefined ? {} : { limit: detail.limit }),
+            };
+        case "edit":
+        case "write":
+            return { kind: "fileChange", changes: [{ op: "unspecified", path: detail.filePath }] };
+        case "search":
+            return { kind: "search", query: detail.query, scope: detail.toolName === "web_search" ? "web" : "content" };
+        case "unknown":
+            return otherToolCall(item.name, detail.input);
+        default:
+            return otherToolCall(item.name);
+    }
+}
+function timelineNarration(item, calls) {
+    switch (item.type) {
+        case "tool_call": {
+            const call = calls.get(item.callId) ?? (item.status === "running" ? toolCall(item) : otherToolCall(item.name));
+            calls.set(item.callId, call);
+            return item.status === "running"
+                ? { type: "tool", phase: "started", id: item.callId, name: item.name, call }
+                : {
+                    type: "tool",
+                    phase: "completed",
+                    id: item.callId,
+                    name: item.name,
+                    call,
+                    result: { status: item.status === "completed" ? "ok" : "error" },
+                };
+        }
+        case "error":
+        case "notification":
+            return { type: "note", text: item.message };
+        case "compaction":
+            return { type: "note", text: `Context compaction ${item.status}` };
+        case "reasoning":
+        case "user_message":
+        case "assistant_message":
+            return undefined;
+        default:
+            return { type: "unknown", kind: item.type };
+    }
+}
+/** Live fragments belong to a canonical admitted turn, not agent-wide status. */
+export class PaseoTurn {
+    messageId;
+    events = new AgentEventChannel();
+    admission;
+    completion;
+    admit;
+    rejectAdmission;
+    finish;
+    rejectCompletion;
+    turnId;
+    messages = [];
+    messagesById = new Map();
+    calls = new Map();
+    answer = "";
+    assistantContiguous = false;
+    settled = false;
+    terminal = false;
+    constructor(messageId) {
+        this.messageId = messageId;
+        this.admission = new Promise((resolve, reject) => {
+            this.admit = resolve;
+            this.rejectAdmission = reject;
+        });
+        this.completion = new Promise((resolve, reject) => {
+            this.finish = resolve;
+            this.rejectCompletion = reject;
+        });
+        void this.admission.catch(() => undefined);
+        void this.completion.catch(() => undefined);
+    }
+    receive(event) {
+        if (this.settled)
+            return;
+        if (event.type === "timeline" &&
+            event.item.type === "user_message" &&
+            event.item.clientMessageId === this.messageId) {
+            if (event.turnId === undefined)
+                return this.fail(new Error("Paseo native admission omitted turnId"));
+            if (this.turnId !== undefined) {
+                if (this.turnId !== event.turnId)
+                    this.fail(new Error("Paseo canonical admission changed native turn"));
+                return;
+            }
+            this.turnId = event.turnId;
+            this.admit(event.turnId);
+            return;
+        }
+        if (!("turnId" in event) || this.turnId === undefined || event.turnId !== this.turnId)
+            return;
+        if (event.type === "timeline") {
+            if (event.item.type === "assistant_message")
+                this.appendAssistant(event.item);
+            else {
+                this.assistantContiguous = false;
+                const narration = timelineNarration(event.item, this.calls);
+                if (narration !== undefined)
+                    this.events.emit(narration);
+            }
+        }
+        else if (event.type === "turn_completed") {
+            this.settled = true;
+            this.finish({
+                kind: "answered",
+                answer: this.answer,
+                historyId: this.turnId,
+            });
+        }
+        else if (event.type === "turn_failed" || event.type === "turn_canceled") {
+            this.settled = true;
+            this.finish({ kind: "failed", diagnostic: event.type === "turn_failed" ? event.error : event.reason });
+        }
+        if (this.settled) {
+            this.terminal = true;
+            for (const message of this.messages)
+                this.events.emit({ type: "assistant", text: message.text });
+        }
+    }
+    appendAssistant(item) {
+        // Native final text is the last contiguous assistant segment; narration keeps all messages.
+        this.answer = this.assistantContiguous ? this.answer + item.text : item.text;
+        const previous = item.messageId === undefined
+            ? this.assistantContiguous
+                ? this.messages.at(-1)
+                : undefined
+            : this.messagesById.get(item.messageId);
+        this.assistantContiguous = true;
+        if (previous !== undefined)
+            previous.text += item.text;
+        else {
+            const message = { ...(item.messageId === undefined ? {} : { id: item.messageId }), text: item.text };
+            this.messages.push(message);
+            if (item.messageId !== undefined)
+                this.messagesById.set(item.messageId, message);
+        }
+    }
+    fail(error) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.rejectAdmission(error);
+        this.rejectCompletion(error);
+    }
+}

package/build/src/akuma/providers/paseo/index.d.ts

@@ -0,0 +1,9 @@
+import { DaemonClient, type DaemonClientConfig } from "@getpaseo/client/internal/daemon-client";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+type PaseoClient = Pick<DaemonClient, "connect" | "close" | "createAgent" | "fetchAgent" | "setAgentModel" | "listProviderModels" | "setAgentThinkingOption" | "sendMessage" | "cancelAgent" | "subscribeAgentTimeline" | "subscribeConnectionStatus">;
+export type PaseoDependencies = Readonly<{
+    createClient?(config: DaemonClientConfig): PaseoClient;
+}>;
+export declare function createPaseoProvider(execution: ProviderExecution, dependencies?: PaseoDependencies): ProviderAdapter;
+export {};