@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/provider.js

@@ -1,220 +1,9 @@
-import { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
+export { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
 export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
 export const AGENT_EVENT_TEXT_LIMIT = 16_384;
 export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
 export const AGENT_EVENT_QUEUE_LIMIT = 256;
-const AGENT_EVENT_TYPES = {
-    session: true,
-    assistant: true,
-    thought: true,
-    tool: true,
-    note: true,
-    unknown: true,
-};
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-export { decodeResumeCoordinate, encodeResumeCoordinate };
-function eventType(value) {
-    return typeof value === "string" && Object.hasOwn(AGENT_EVENT_TYPES, value);
-}
-const SEARCH_SCOPES = {
-    content: true,
-    files: true,
-    web: true,
-};
-function decodePositiveLine(value) {
-    if (value === undefined)
-        return undefined;
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : null;
-}
-function decodeOptionalText(value) {
-    if (value === undefined)
-        return undefined;
-    return typeof value === "string" ? value : null;
-}
-function decodeSearchScope(value) {
-    if (value === undefined)
-        return undefined;
-    return typeof value === "string" && Object.hasOwn(SEARCH_SCOPES, value) ? value : null;
-}
-function decodeRunCall(call) {
-    return typeof call.command === "string" ? { kind: "run", command: call.command } : null;
-}
-function decodeReadCall(call) {
-    if (typeof call.path !== "string")
-        return null;
-    const offset = decodePositiveLine(call.offset);
-    const limit = decodePositiveLine(call.limit);
-    if (offset === null || limit === null)
-        return null;
-    return {
-        kind: "read",
-        path: call.path,
-        ...(offset === undefined ? {} : { offset }),
-        ...(limit === undefined ? {} : { limit }),
-    };
-}
-function decodeSearchCall(call) {
-    if (typeof call.query !== "string")
-        return null;
-    const scope = decodeSearchScope(call.scope);
-    const path = decodeOptionalText(call.path);
-    const glob = decodeOptionalText(call.glob);
-    if (scope === null || path === null || glob === null)
-        return null;
-    return {
-        kind: "search",
-        query: call.query,
-        ...(scope === undefined ? {} : { scope }),
-        ...(path === undefined ? {} : { path }),
-        ...(glob === undefined ? {} : { glob }),
-    };
-}
-function decodeNonnegativeCount(value) {
-    return Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-function decodeDiffstat(value) {
-    if (value === undefined)
-        return undefined;
-    const diffstat = object(value);
-    if (diffstat === null)
-        return null;
-    const added = decodeNonnegativeCount(diffstat.added);
-    const removed = decodeNonnegativeCount(diffstat.removed);
-    return added === null || removed === null ? null : { added, removed };
-}
-function decodeFileChangeMember(value) {
-    const change = object(value);
-    if (change === null ||
-        (change.op !== "add" && change.op !== "update" && change.op !== "delete" && change.op !== "unspecified") ||
-        typeof change.path !== "string")
-        return null;
-    const diffstat = decodeDiffstat(change.diffstat);
-    if (diffstat === null)
-        return null;
-    return {
-        op: change.op,
-        path: change.path,
-        ...(diffstat === undefined ? {} : { diffstat }),
-    };
-}
-function decodeFileChangeCall(call) {
-    if (!Array.isArray(call.changes))
-        return null;
-    const changes = call.changes.map(decodeFileChangeMember);
-    return changes.every((change) => change !== null) ? { kind: "fileChange", changes } : null;
-}
-function decodeToolInput(value) {
-    if (value === undefined)
-        return undefined;
-    const input = object(value);
-    if (input === null || typeof input.json !== "string" || typeof input.truncated !== "boolean")
-        return null;
-    return { json: input.json, truncated: input.truncated };
-}
-function decodeOtherCall(call) {
-    if (typeof call.display !== "string")
-        return null;
-    const input = decodeToolInput(call.input);
-    return input === null ? null : { kind: "other", display: call.display, ...(input === undefined ? {} : { input }) };
-}
-function decodeToolCall(value) {
-    const call = object(value);
-    if (call === null)
-        return null;
-    switch (call.kind) {
-        case "run":
-            return decodeRunCall(call);
-        case "read":
-            return decodeReadCall(call);
-        case "search":
-            return decodeSearchCall(call);
-        case "fileChange":
-            return decodeFileChangeCall(call);
-        case "other":
-            return decodeOtherCall(call);
-        default:
-            return null;
-    }
-}
-function decodeToolResult(value) {
-    const result = object(value);
-    if (result === null || (result.status !== "ok" && result.status !== "error"))
-        return null;
-    if (result.message !== undefined && typeof result.message !== "string")
-        return null;
-    if (result.exitCode !== undefined && !Number.isSafeInteger(result.exitCode))
-        return null;
-    return {
-        status: result.status,
-        ...(result.message === undefined ? {} : { message: result.message }),
-        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
-    };
-}
-function decodeToolEvent(event) {
-    if (event.truncated !== undefined && event.truncated !== true)
-        return null;
-    if (typeof event.id !== "string" || typeof event.name !== "string")
-        return null;
-    const call = decodeToolCall(event.call);
-    if (call !== null && event.phase === "started" && event.result === undefined) {
-        return {
-            type: "tool",
-            phase: "started",
-            id: event.id,
-            name: event.name,
-            call,
-            ...(event.truncated === true ? { truncated: true } : {}),
-        };
-    }
-    const result = decodeToolResult(event.result);
-    if (call !== null && event.phase === "completed" && result !== null) {
-        return {
-            type: "tool",
-            phase: "completed",
-            id: event.id,
-            name: event.name,
-            call,
-            result,
-            ...(event.truncated === true ? { truncated: true } : {}),
-        };
-    }
-    return null;
-}
-function decodeTypedEvent(type, event) {
-    if (type !== "session" && event.truncated !== undefined && event.truncated !== true)
-        return null;
-    const truncated = event.truncated === true ? { truncated: true } : {};
-    switch (type) {
-        case "assistant":
-        case "thought":
-            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "note":
-            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "unknown":
-            return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
-        case "session": {
-            const coordinate = decodeResumeCoordinate(event.coordinate);
-            return coordinate === null ? null : { type, coordinate };
-        }
-        case "tool":
-            return decodeToolEvent(event);
-        default:
-            return type;
-    }
-}
-export function decodeAgentEvent(value) {
-    const event = object(value);
-    if (event === null || !eventType(event.type))
-        throw new Error("Akuma activity has an invalid event shape");
-    const decoded = decodeTypedEvent(event.type, event);
-    if (decoded === null)
-        throw new Error("Akuma activity has an invalid event shape");
-    return decoded;
-}
+export { agentEventSchema, decodeAgentEvent } from "./heart/activity-schema.js";
 function boundedToolCall(call) {
     switch (call.kind) {
         case "run":
@@ -284,13 +73,16 @@ function boundedToolResult(result) {
     };
 }
 export function encodeAgentEvent(event) {
-    const marked = (value, changed) => ({
-        ...value,
-        ...(changed || ("truncated" in event && event.truncated === true) ? { truncated: true } : {}),
-    });
+    const marked = (value, changed) => changed || ("truncated" in event && event.truncated === true) ? { ...value, truncated: true } : value;
     switch (event.type) {
-        case "session":
-            return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
+        case "session": {
+            const coordinate = "sessionFile" in event.coordinate
+                ? event.coordinate.sessionId === undefined
+                    ? { sessionFile: event.coordinate.sessionFile }
+                    : { sessionFile: event.coordinate.sessionFile, sessionId: event.coordinate.sessionId }
+                : { sessionId: event.coordinate.sessionId };
+            return { type: event.type, coordinate };
+        }
         case "assistant":
             return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
         case "thought":

package/build/src/akuma/providers/acp/config.d.ts

@@ -4,6 +4,8 @@ export type AcpExecutionConfig = Readonly<{
     argvAfter: readonly string[];
     modelArg?: string;
     effortArg?: string;
+    modelConfigId?: string;
+    effortConfigId?: string;
     systemPromptArg?: string;
     systemPromptMode?: SystemPromptMode;
 }>;

package/build/src/akuma/providers/acp/config.js

@@ -7,12 +7,32 @@ function argumentName(value, key) {
     }
     return selected;
 }
+function validateSelectorMappings(config) {
+    if (config.modelArg !== undefined && config.modelConfigId !== undefined) {
+        throw new TypeError("ACP provider config cannot map model to both an argument and a session option");
+    }
+    if (config.effortArg !== undefined && config.effortConfigId !== undefined) {
+        throw new TypeError("ACP provider config cannot map effort to both an argument and a session option");
+    }
+    if (config.modelConfigId !== undefined && config.modelConfigId === config.effortConfigId) {
+        throw new TypeError("ACP provider config model and effort must use different session options");
+    }
+}
 export function decodeAcpConfig(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new TypeError("ACP provider config must be an object");
     }
     const config = value;
-    const unknown = Object.keys(config).find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg", "systemPromptMode"].includes(key));
+    const unknown = Object.keys(config).find((key) => ![
+        "argvBefore",
+        "argvAfter",
+        "effortArg",
+        "modelArg",
+        "modelConfigId",
+        "effortConfigId",
+        "systemPromptArg",
+        "systemPromptMode",
+    ].includes(key));
     if (unknown !== undefined)
         throw new TypeError(`ACP provider config has unknown field ${unknown}`);
     if (!Array.isArray(config.argvBefore) ||
@@ -25,6 +45,9 @@ export function decodeAcpConfig(value) {
     }
     const modelArg = argumentName(config, "modelArg");
     const effortArg = argumentName(config, "effortArg");
+    const modelConfigId = argumentName(config, "modelConfigId");
+    const effortConfigId = argumentName(config, "effortConfigId");
+    validateSelectorMappings({ modelArg, effortArg, modelConfigId, effortConfigId });
     const systemPromptArg = argumentName(config, "systemPromptArg");
     const systemPromptMode = config.systemPromptMode;
     if (systemPromptMode !== undefined && systemPromptMode !== "append" && systemPromptMode !== "replace") {
@@ -38,6 +61,8 @@ export function decodeAcpConfig(value) {
         argvAfter: Object.freeze([...config.argvAfter]),
         ...(modelArg === undefined ? {} : { modelArg }),
         ...(effortArg === undefined ? {} : { effortArg }),
+        ...(modelConfigId === undefined ? {} : { modelConfigId }),
+        ...(effortConfigId === undefined ? {} : { effortConfigId }),
         ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
         ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
     });

package/build/src/akuma/providers/acp/core.d.ts

@@ -10,6 +10,8 @@ export type AcpDependencies = Readonly<{
     interpretTool?: AcpToolInterpreter;
     freshSessionMeta?: AcpSessionMeta;
     loadSessionMeta?: AcpSessionMeta;
+    configureClient?: (client: AcpSdk.ClientApp) => void;
+    onTerminal?: () => void;
 }>;
 export type AcpLiveSession = Readonly<{
     session: Session;
@@ -20,5 +22,10 @@ export type AcpLiveSession = Readonly<{
 type AcpLaunch = Readonly<{
     argv: readonly [string, ...string[]];
     env?: Readonly<Record<string, string>>;
+    sessionOptions?: readonly Readonly<{
+        field: "model" | "effort";
+        id: string;
+        value: string;
+    }>[];
 }>;
 export declare function startAcpSession(launch: AcpLaunch, input: AcpStartInput, dependencies?: AcpDependencies, custody?: AttemptCustody): Promise<AcpLiveSession>;

package/build/src/akuma/providers/acp/core.js

@@ -18,10 +18,12 @@ function diagnostic(acp, error) {
     }
     return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
 }
-function createAcpClient(acp, onUpdate) {
-    return acp
+function createAcpClient(acp, onUpdate, configure) {
+    const client = acp
         .client({ name: "keiyaku" })
         .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
+    configure?.(client);
+    return client;
 }
 function promptResult(response) {
     if (response.stopReason === "end_turn" ||
@@ -34,7 +36,7 @@ function promptResult(response) {
 function requestMeta(meta) {
     return meta === undefined || Object.keys(meta).length === 0 ? {} : { _meta: meta };
 }
-async function establishSession(acp, agent, input, dependencies) {
+async function establishSession(acp, agent, input, dependencies, selections) {
     const initialized = await agent.request(acp.methods.agent.initialize, {
         protocolVersion: acp.PROTOCOL_VERSION,
         clientInfo: { name: "keiyaku", version: "4" },
@@ -42,25 +44,53 @@ async function establishSession(acp, agent, input, dependencies) {
     if (input.session.kind === "resume" && initialized.agentCapabilities?.loadSession !== true) {
         throw new Error("ACP agent does not advertise session/load");
     }
+    let sessionId;
+    let configOptions;
     if (input.session.kind === "fresh") {
-        return (await agent.request(acp.methods.agent.session.new, {
+        const created = await agent.request(acp.methods.agent.session.new, {
             cwd: input.cwd,
             mcpServers: [],
             ...requestMeta(dependencies.freshSessionMeta),
-        })).sessionId;
+        });
+        sessionId = created.sessionId;
+        configOptions = created.configOptions;
+    }
+    else {
+        const coordinate = input.session.coordinate.sessionId;
+        if (coordinate === undefined)
+            throw new Error("ACP resume coordinate has no session id");
+        sessionId = coordinate;
+        const loaded = await agent.request(acp.methods.agent.session.load, {
+            cwd: input.cwd,
+            mcpServers: [],
+            sessionId,
+            ...requestMeta(dependencies.loadSessionMeta),
+        });
+        configOptions = loaded.configOptions;
+    }
+    for (const selection of selections) {
+        const selected = configOptions?.find((option) => option.id === selection.id);
+        if (selected?.type !== "select")
+            throw new Error(`ACP ${selection.field} option '${selection.id}' is unavailable`);
+        const choices = selected.options.flatMap((option) => ("options" in option ? option.options : [option]));
+        if (selected.currentValue === selection.value)
+            continue;
+        if (!choices.some((option) => option.value === selection.value)) {
+            throw new Error(`ACP ${selection.field} value '${selection.value}' is unavailable`);
+        }
+        const updated = await agent.request(acp.methods.agent.session.setConfigOption, {
+            sessionId,
+            configId: selection.id,
+            value: selection.value,
+        });
+        configOptions = updated.configOptions;
+        if (configOptions.find((option) => option.id === selection.id)?.currentValue !== selection.value) {
+            throw new Error(`ACP ${selection.field} option '${selection.id}' did not select '${selection.value}'`);
+        }
     }
-    const sessionId = input.session.coordinate.sessionId;
-    if (sessionId === undefined)
-        throw new Error("ACP resume coordinate has no session id");
-    await agent.request(acp.methods.agent.session.load, {
-        cwd: input.cwd,
-        mcpServers: [],
-        sessionId,
-        ...requestMeta(dependencies.loadSessionMeta),
-    });
     return sessionId;
 }
-function createAcpTurn(acp, connection, interpret) {
+function createAcpTurn(acp, connection, interpret, onTerminal) {
     const events = new AgentEventChannel();
     let state = EMPTY_ACP_EVENT_STATE;
     let terminal = false;
@@ -80,6 +110,7 @@ function createAcpTurn(acp, connection, interpret) {
         if (terminal)
             return;
         terminal = true;
+        onTerminal?.();
         let completionResult = result;
         const failCleanup = (error) => {
             completionResult = { kind: "failed", diagnostic: `ACP cleanup failed: ${diagnostic(acp, error)}` };
@@ -169,10 +200,10 @@ export async function startAcpSession(launch, input, dependencies = {}, custody)
     const connection = createAcpClient(acp, (notification) => {
         if (notification.sessionId === sessionId)
             turn.update(notification.update);
-    }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
-    turn = createAcpTurn(acp, connection, dependencies.interpretTool);
+    }, dependencies.configureClient).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
+    turn = createAcpTurn(acp, connection, dependencies.interpretTool, dependencies.onTerminal);
     try {
-        sessionId = await abortable(establishSession(acp, connection.agent, input, dependencies), signal);
+        sessionId = await abortable(establishSession(acp, connection.agent, input, dependencies, launch.sessionOptions ?? []), signal);
         turn.events.emit({ type: "session", coordinate: { sessionId } });
         const session = beginAcpPrompt({ acp, agent: connection.agent }, child, turn, sessionId, input);
         return { session, agent: connection.agent, sessionId, open: turn.open };

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

@@ -6,11 +6,11 @@ function optionAdmission(options, config) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "ACP provider does not support the network option" };
     }
-    if (options.model !== undefined && config.modelArg === undefined) {
-        return { kind: "refused", diagnostic: "ACP provider has no model argument mapping" };
+    if (options.model !== undefined && config.modelArg === undefined && config.modelConfigId === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no model mapping" };
     }
-    if (options.effort !== undefined && config.effortArg === undefined) {
-        return { kind: "refused", diagnostic: "ACP provider has no effort argument mapping" };
+    if (options.effort !== undefined && config.effortArg === undefined && config.effortConfigId === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no effort mapping" };
     }
     if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
         if (config.systemPromptArg === undefined) {
@@ -32,9 +32,9 @@ function argv(execution, config, options) {
     if (execution.executable === undefined)
         throw new Error("ACP provider execution requires executable");
     const values = [execution.executable, ...config.argvBefore];
-    if (options.model !== undefined)
+    if (options.model !== undefined && config.modelArg !== undefined)
         values.push(config.modelArg, options.model);
-    if (options.effort !== undefined)
+    if (options.effort !== undefined && config.effortArg !== undefined)
         values.push(config.effortArg, options.effort);
     if (options.systemPrompt !== undefined && config.systemPromptArg !== undefined) {
         values.push(config.systemPromptArg, options.systemPrompt);
@@ -50,6 +50,14 @@ export function createAcpProvider(execution, dependencies = {}) {
         const launch = {
             argv: argv(execution, config, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
+            sessionOptions: [
+                ...(input.options.model === undefined || config.modelConfigId === undefined
+                    ? []
+                    : [{ field: "model", id: config.modelConfigId, value: input.options.model }]),
+                ...(input.options.effort === undefined || config.effortConfigId === undefined
+                    ? []
+                    : [{ field: "effort", id: config.effortConfigId, value: input.options.effort }]),
+            ],
         };
         return (await startAcpSession(launch, input, dependencies, custody)).session;
     };

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

@@ -1,6 +1,7 @@
 import { createProviderAttempt } from "../../provider.js";
 import { startAcpSession, } from "../acp/core.js";
-const INTERJECT_METHOD = "x.ai/interject";
+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;
 }
@@ -108,23 +109,34 @@ function argv(execution, options) {
     values.push("stdio");
     return values;
 }
-function withInterject(live) {
+function withInterject(live, pending) {
     return {
         ...live.session,
-        tell: async (tell) => {
+        tell: (tell) => {
             if (!live.open())
-                return { kind: "turn-ended" };
-            const response = await live.agent.request(INTERJECT_METHOD, {
+                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 });
+            });
+            void live.agent
+                .request(INTERJECT_METHOD, {
                 sessionId: live.sessionId,
                 text: tell.text,
                 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);
+                }
+            }, (error) => {
+                pending.get(tell.id)?.reject(error);
+                pending.delete(tell.id);
             });
-            if (!live.open())
-                return { kind: "turn-ended" };
-            if (response === null || typeof response !== "object" || response.status !== "queued") {
-                throw new Error("Grok Build interject did not return queued");
-            }
-            return { kind: "accepted", fence: tell.id };
+            return receipt;
         },
     };
 }
@@ -132,17 +144,36 @@ 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();
+        let live;
         const launch = {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
         };
         const sessionMeta = grokSessionMeta(execution.config, input.options);
-        return withInterject(await startAcpSession(launch, input, {
+        live = await startAcpSession(launch, input, {
             ...dependencies,
+            configureClient: (client) => {
+                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 });
+                });
+            },
+            onTerminal: () => {
+                for (const waiter of pending.values())
+                    waiter.resolve({ kind: "turn-ended" });
+                pending.clear();
+            },
             interpretTool: interpretGrokTool,
             freshSessionMeta: { ...(dependencies.freshSessionMeta ?? {}), ...(sessionMeta.freshSessionMeta ?? {}) },
             loadSessionMeta: { ...(dependencies.loadSessionMeta ?? {}), ...(sessionMeta.loadSessionMeta ?? {}) },
-        }, custody));
+        }, custody);
+        return withInterject(live, pending);
     };
     return {
         admitOptions: optionAdmission,

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

@@ -1,7 +1,7 @@
 import type { ProviderAdapter } from "../provider.js";
-import { type ProviderExecution } from "../provider-recipe.js";
-export declare function decodeProviderExecution(input: unknown): ProviderExecution;
-export declare function resolveProviderExecution(input: unknown): Promise<Readonly<{
+import type { ProviderExecution } from "../provider-recipe.js";
+export { decodeProviderRecipe as decodeProviderExecution } from "../provider-recipe.js";
+export declare function resolveProviderExecution(execution: ProviderExecution): Promise<Readonly<{
     execution: ProviderExecution;
     adapter: ProviderAdapter;
 }>>;

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

@@ -1,14 +1,4 @@
-import { decodeProviderRecipe } from "../provider-recipe.js";
-export function decodeProviderExecution(input) {
-    const decoded = decodeProviderRecipe(input);
-    return Object.freeze({
-        name: decoded.name,
-        kind: decoded.kind,
-        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
-        ...(decoded.config === undefined ? {} : { config: decoded.config }),
-        ...(decoded.env === undefined ? {} : { env: decoded.env }),
-    });
-}
+export { decodeProviderRecipe as decodeProviderExecution } from "../provider-recipe.js";
 async function adapterFor(execution) {
     if (execution.kind === "acp")
         return (await import("./acp/index.js")).createAcpProvider(execution);
@@ -28,7 +18,6 @@ async function adapterFor(execution) {
         return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }
-export async function resolveProviderExecution(input) {
-    const execution = decodeProviderExecution(input);
+export async function resolveProviderExecution(execution) {
     return Object.freeze({ execution, adapter: await adapterFor(execution) });
 }

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

@@ -0,0 +1,28 @@
+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
+ * retired; a teardown rejection escapes through it, and an unprovable
+ * retirement leaves it pending so existing custody reports the attempt hung.
+ */
+export type OwnedEventStream = Readonly<{
+    /** Subscription barrier: resolves once the native subscription exists, rejects on setup failure. */
+    ready: Promise<void>;
+    /** Reads the next native event. A pending read is interrupted by `retire`. */
+    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. */
+    closed: Promise<void>;
+}>;
+export declare function ownEventStream(input: Readonly<{
+    directory: string;
+    /** The session/attempt notification signal this owner's controller follows. */
+    signal: AbortSignal;
+    subscribe(request: OpencodeEventSubscriptionRequest): Promise<Readonly<{
+        stream: AsyncIterable<unknown>;
+    }>>;
+    custody?: AttemptCustody;
+}>): OwnedEventStream;