@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/akuma/provider.js

@@ -16,82 +16,110 @@ function object(value) {
         : null;
 }
 export { decodeResumeCoordinate, encodeResumeCoordinate };
-function optionText(options, field, blank) {
-    const selected = options[field];
-    if (selected === undefined)
+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;
-    if (typeof selected !== "string" || (blank === "refuse" && selected.trim().length === 0)) {
-        throw new TypeError(`provider option ${field} must be ${blank === "allow" ? "a string" : "a nonblank string"}`);
-    }
-    return selected;
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : null;
 }
-function optionEnum(options, field, allowed) {
-    const selected = options[field];
-    if (selected === undefined)
+function decodeOptionalText(value) {
+    if (value === undefined)
         return undefined;
-    if (typeof selected !== "string" || !allowed.includes(selected)) {
-        throw new TypeError(`provider option ${field} must be ${allowed.join(", ")}`);
-    }
-    return selected;
-}
-export function decodeProviderOptions(value) {
-    const options = object(value);
-    if (options === null)
-        throw new TypeError("provider options must be an object");
-    const allowed = ["access", "effort", "model", "network", "systemPrompt"];
-    const unknown = Object.keys(options).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider options have unknown field ${unknown}`);
-    const model = optionText(options, "model", "refuse");
-    const effort = optionText(options, "effort", "refuse");
-    const access = optionEnum(options, "access", ["read", "write", "auto"]);
-    const network = optionEnum(options, "network", ["disabled", "enabled"]);
-    const systemPrompt = optionText(options, "systemPrompt", "allow");
-    return Object.freeze({
-        ...(model === undefined ? {} : { model }),
-        ...(effort === undefined ? {} : { effort }),
-        ...(access === undefined ? {} : { access }),
-        ...(network === undefined ? {} : { network }),
-        ...(systemPrompt === undefined ? {} : { systemPrompt }),
-    });
+    return typeof value === "string" ? value : null;
 }
-function eventType(value) {
-    return typeof value === "string" && Object.hasOwn(AGENT_EVENT_TYPES, value);
+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")
+        || 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 decodeOtherCall(call) {
+    return typeof call.display === "string" ? { kind: "other", display: call.display } : null;
 }
 function decodeToolCall(value) {
     const call = object(value);
-    if (call?.kind === "run" && typeof call.command === "string")
-        return { kind: "run", command: call.command };
-    if (call?.kind === "read" && typeof call.path === "string")
-        return { kind: "read", path: call.path };
-    if (call?.kind === "search" && typeof call.query === "string")
-        return { kind: "search", query: call.query };
-    if (call?.kind === "fileChange" && Array.isArray(call.changes)) {
-        const changes = call.changes.map((value) => {
-            const change = object(value);
-            if (change === null || (change.op !== "add" && change.op !== "update" && change.op !== "delete")
-                || typeof change.path !== "string")
-                return null;
-            const rawDiffstat = change.diffstat;
-            const op = change.op;
-            if (rawDiffstat === undefined)
-                return { op, path: change.path };
-            const diffstat = object(rawDiffstat);
-            if (diffstat === null || !Number.isSafeInteger(diffstat.added) || !Number.isSafeInteger(diffstat.removed)
-                || diffstat.added < 0 || diffstat.removed < 0)
-                return null;
-            return {
-                op,
-                path: change.path,
-                diffstat: { added: diffstat.added, removed: diffstat.removed },
-            };
-        });
-        if (changes.every((change) => change !== null))
-            return { kind: "fileChange", changes };
+    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;
     }
-    if (call?.kind === "other" && typeof call.display === "string")
-        return { kind: "other", display: call.display };
-    return null;
 }
 function decodeToolResult(value) {
     const result = object(value);
@@ -153,8 +181,27 @@ export function decodeAgentEvent(value) {
 function boundedToolCall(call) {
     switch (call.kind) {
         case "run": return { value: { kind: call.kind, command: boundedEventText(call.command) }, truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT };
-        case "read": return { value: { kind: call.kind, path: boundedEventText(call.path) }, truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT };
-        case "search": return { value: { kind: call.kind, query: boundedEventText(call.query) }, truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT };
+        case "read": return {
+            value: {
+                kind: call.kind,
+                path: boundedEventText(call.path),
+                ...(call.offset === undefined ? {} : { offset: call.offset }),
+                ...(call.limit === undefined ? {} : { limit: call.limit }),
+            },
+            truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT,
+        };
+        case "search": return {
+            value: {
+                kind: call.kind,
+                query: boundedEventText(call.query),
+                ...(call.scope === undefined ? {} : { scope: call.scope }),
+                ...(call.path === undefined ? {} : { path: boundedEventText(call.path) }),
+                ...(call.glob === undefined ? {} : { glob: boundedEventText(call.glob) }),
+            },
+            truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT
+                || (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT)
+                || (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
+        };
         case "fileChange": return {
             value: {
                 kind: call.kind,

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

@@ -0,0 +1,19 @@
+import * as acp from "@agentclientprotocol/sdk";
+import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
+import { type ProviderAdapter, type Session } from "../../provider.js";
+export type AcpStartInput = Parameters<ProviderAdapter["start"]>[0] | Parameters<NonNullable<ProviderAdapter["resume"]>>[0];
+export type AcpDependencies = Readonly<{
+    spawnProcess?: typeof spawnStdioProcess;
+}>;
+export type AcpLiveSession = Readonly<{
+    session: Session;
+    agent: acp.ClientContext;
+    sessionId: string;
+    open(): boolean;
+}>;
+type AcpLaunch = Readonly<{
+    argv: readonly [string, ...string[]];
+    env?: Readonly<Record<string, string>>;
+}>;
+export declare function startAcpSession(launch: AcpLaunch, input: AcpStartInput, dependencies?: AcpDependencies): Promise<AcpLiveSession>;
+export {};

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

@@ -0,0 +1,159 @@
+import * as acp from "@agentclientprotocol/sdk";
+import { Readable, Writable } from "node:stream";
+import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
+import { abortable } from "../../abort.js";
+import { AgentEventChannel, } from "../../provider.js";
+import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate } from "./events.js";
+function diagnostic(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    if (!(error instanceof acp.RequestError) || error.data === undefined)
+        return error.message;
+    let data;
+    try {
+        data = typeof error.data === "string" ? error.data : JSON.stringify(error.data);
+    }
+    catch {
+        data = String(error.data);
+    }
+    return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
+}
+function createAcpClient(onUpdate) {
+    return acp.client({ name: "keiyaku" })
+        .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
+}
+function promptResult(response) {
+    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens"
+        || response.stopReason === "max_turn_requests") {
+        return { kind: "answered", answer: "" };
+    }
+    return { kind: "failed", diagnostic: `ACP prompt ended ${response.stopReason}` };
+}
+async function establishSession(agent, input) {
+    const initialized = await agent.request(acp.methods.agent.initialize, {
+        protocolVersion: acp.PROTOCOL_VERSION,
+        clientInfo: { name: "keiyaku", version: "4" },
+    });
+    if (input.session.kind === "resume" && initialized.agentCapabilities?.loadSession !== true) {
+        throw new Error("ACP agent does not advertise session/load");
+    }
+    if (input.session.kind === "fresh") {
+        return (await agent.request(acp.methods.agent.session.new, { cwd: input.cwd, mcpServers: [] })).sessionId;
+    }
+    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 });
+    return sessionId;
+}
+function createAcpTurn(connection) {
+    const events = new AgentEventChannel();
+    let state = EMPTY_ACP_EVENT_STATE;
+    let terminal = false;
+    let resolveCompletion;
+    const completion = new Promise((resolve) => { resolveCompletion = resolve; });
+    const update = (next) => {
+        if (terminal)
+            return;
+        const mapped = mapAcpUpdate(next, state);
+        state = mapped.state;
+        for (const event of mapped.events)
+            events.emit(event);
+    };
+    const finish = async (result, cleanup) => {
+        if (terminal)
+            return;
+        terminal = true;
+        let completionResult = result;
+        const failCleanup = (error) => {
+            completionResult = { kind: "failed", diagnostic: `ACP cleanup failed: ${diagnostic(error)}` };
+        };
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            failCleanup(error);
+        }
+        try {
+            connection.close();
+        }
+        catch (error) {
+            failCleanup(error);
+        }
+        const flushed = flushAcpEvents(state);
+        for (const event of flushed.events)
+            events.emit(event);
+        events.end();
+        resolveCompletion(completionResult.kind === "answered"
+            ? { ...completionResult, answer: flushed.state.answer }
+            : completionResult);
+    };
+    return {
+        events,
+        completion,
+        update,
+        finish,
+        open: () => !terminal,
+    };
+}
+function beginAcpPrompt(agent, child, turn, sessionId, input) {
+    void agent.request(acp.methods.agent.session.prompt, {
+        sessionId,
+        prompt: [{ type: "text", text: input.body }, ...input.launchTells.map(({ text }) => ({ type: "text", text }))],
+    }).then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(error) }, () => child.endInputAndDrain()));
+    void child.exited.then((exit) => turn.finish({
+        kind: "failed",
+        diagnostic: exit.stderr || `ACP process exited${exit.code === null ? "" : ` with code ${exit.code}`}`,
+    }, () => child.endInputAndDrain()));
+    return {
+        admission: { fence: sessionId },
+        events: turn.events,
+        completion: turn.completion,
+        abort: async () => {
+            let result = { kind: "failed", diagnostic: "ACP turn cancelled" };
+            try {
+                await agent.notify(acp.methods.agent.session.cancel, { sessionId });
+            }
+            catch (error) {
+                result = { kind: "failed", diagnostic: diagnostic(error) };
+            }
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish(result, () => child.close(true));
+        },
+    };
+}
+export async function startAcpSession(launch, input, dependencies = {}) {
+    const signal = input.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
+        argv: launch.argv,
+        cwd: input.cwd,
+        env: { ...globalThis.process.env, ...launch.env },
+    });
+    let sessionId;
+    let turn;
+    const connection = createAcpClient((notification) => {
+        if (notification.sessionId === sessionId)
+            turn.update(notification.update);
+    }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
+    turn = createAcpTurn(connection);
+    try {
+        sessionId = await abortable(establishSession(connection.agent, input), signal);
+        turn.events.emit({ type: "session", coordinate: { sessionId } });
+        const session = beginAcpPrompt(connection.agent, child, turn, sessionId, input);
+        return { session, agent: connection.agent, sessionId, open: turn.open };
+    }
+    catch (error) {
+        connection.close(error);
+        try {
+            await child.close(true);
+        }
+        catch (cleanup) {
+            throw new Error(`${diagnostic(error)}; ACP cleanup failed: ${diagnostic(cleanup)}`, { cause: error });
+        }
+        turn.events.end();
+        throw error;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { SessionUpdate } from "@agentclientprotocol/sdk";
+import { type AgentEvent } from "../../provider.js";
+type OpenBlock = Readonly<{
+    type: "assistant" | "thought";
+    text: string;
+}> | null;
+export type AcpEventState = Readonly<{
+    answer: string;
+    assistantMessageId: string | null;
+    open: OpenBlock;
+    tools: ReadonlyMap<string, string>;
+}>;
+type AcpEventMapping = Readonly<{
+    events: readonly AgentEvent[];
+    state: AcpEventState;
+}>;
+export declare const EMPTY_ACP_EVENT_STATE: AcpEventState;
+export declare function flushAcpEvents(state: AcpEventState, boundary?: readonly AgentEvent[]): AcpEventMapping;
+export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState): AcpEventMapping;
+export {};

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

@@ -0,0 +1,73 @@
+import { noteEvent, unknownEvent } from "../../provider.js";
+export const EMPTY_ACP_EVENT_STATE = Object.freeze({
+    answer: "",
+    assistantMessageId: null,
+    open: null,
+    tools: new Map(),
+});
+export function flushAcpEvents(state, boundary = []) {
+    const events = state.open === null ? boundary : [{ type: state.open.type, text: state.open.text }, ...boundary];
+    return {
+        events,
+        state: state.open === null ? state : { ...state, open: null },
+    };
+}
+function appendBlock(state, type, text, messageId) {
+    const newAssistantMessage = type === "assistant"
+        && messageId !== undefined
+        && state.assistantMessageId !== messageId;
+    const flushed = state.open === null || (state.open.type === type && !newAssistantMessage)
+        ? { events: [], state }
+        : flushAcpEvents(state);
+    return {
+        events: flushed.events,
+        state: {
+            ...flushed.state,
+            answer: type === "assistant"
+                ? `${newAssistantMessage ? "" : flushed.state.answer}${text}`
+                : flushed.state.answer,
+            assistantMessageId: type === "assistant" && messageId !== undefined
+                ? messageId
+                : flushed.state.assistantMessageId,
+            open: { type, text: `${flushed.state.open?.text ?? ""}${text}` },
+        },
+    };
+}
+export function mapAcpUpdate(update, previous) {
+    switch (update.sessionUpdate) {
+        case "agent_message_chunk":
+        case "agent_thought_chunk": {
+            const text = update.content.type === "text" ? update.content.text : undefined;
+            if (text === undefined)
+                return flushAcpEvents(previous, [unknownEvent(`${update.sessionUpdate}/${update.content.type}`)]);
+            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null
+                ? update.messageId
+                : undefined);
+        }
+        case "user_message_chunk": return flushAcpEvents(previous);
+        case "tool_call":
+        case "tool_call_update": {
+            const name = update.title ?? (update.sessionUpdate === "tool_call" ? undefined : previous.tools.get(update.toolCallId)) ?? "ACP tool";
+            const observed = { name, call: { kind: "other", display: name } };
+            const tools = new Map(previous.tools);
+            if (update.status === "completed" || update.status === "failed") {
+                tools.delete(update.toolCallId);
+                return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
+            }
+            const started = tools.has(update.toolCallId);
+            tools.set(update.toolCallId, name);
+            return started
+                ? flushAcpEvents({ ...previous, tools })
+                : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);
+        }
+        case "plan": return flushAcpEvents(previous, [noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`)]);
+        case "available_commands_update": return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
+        case "current_mode_update": return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
+        case "config_option_update": return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
+        case "session_info_update": return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
+        case "usage_update": return flushAcpEvents(previous);
+        case "plan_update":
+        case "plan_removed": return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
+        default: return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+import { type AcpDependencies } from "./core.js";
+export type AcpExecutionConfig = Readonly<{
+    argvBefore: readonly string[];
+    argvAfter: readonly string[];
+    modelArg?: string;
+    effortArg?: string;
+    systemPromptArg?: string;
+}>;
+export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;
+export declare function createAcpProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -0,0 +1,94 @@
+import { startAcpSession } from "./core.js";
+function argumentName(value, key) {
+    const selected = value[key];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
+    }
+    return selected;
+}
+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"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
+    if (!Array.isArray(config.argvBefore)
+        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
+    }
+    if (!Array.isArray(config.argvAfter)
+        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
+    }
+    const modelArg = argumentName(config, "modelArg");
+    const effortArg = argumentName(config, "effortArg");
+    const systemPromptArg = argumentName(config, "systemPromptArg");
+    return Object.freeze({
+        argvBefore: Object.freeze([...config.argvBefore]),
+        argvAfter: Object.freeze([...config.argvAfter]),
+        ...(modelArg === undefined ? {} : { modelArg }),
+        ...(effortArg === undefined ? {} : { effortArg }),
+        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
+    });
+}
+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.effort !== undefined && config.effortArg === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no effort argument mapping" };
+    }
+    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0 && config.systemPromptArg === undefined) {
+        return { kind: "refused", diagnostic: "ACP provider has no systemPrompt argument mapping" };
+    }
+    return {
+        kind: "admitted",
+        options,
+        ...(options.readonly === undefined ? {} : {
+            readonly: {
+                enforcement: "none",
+                diagnostic: "ACP cannot remove task-surface mutation capabilities",
+            },
+        }),
+    };
+}
+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)
+        values.push(config.modelArg, options.model);
+    if (options.effort !== undefined)
+        values.push(config.effortArg, options.effort);
+    if (options.systemPrompt !== undefined && config.systemPromptArg !== undefined) {
+        values.push(config.systemPromptArg, options.systemPrompt);
+    }
+    values.push(...config.argvAfter);
+    return values;
+}
+export function createAcpProvider(execution, dependencies = {}) {
+    if (execution.executable === undefined)
+        throw new TypeError("ACP provider execution requires executable");
+    const config = decodeAcpConfig(execution.config);
+    const drive = async (input) => {
+        const launch = {
+            argv: argv(execution, config, input.options),
+            ...(execution.env === undefined ? {} : { env: execution.env }),
+        };
+        return (await startAcpSession(launch, input, dependencies)).session;
+    };
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: (options) => optionAdmission(options, config),
+        start: async (input) => await drive(input),
+        resume: async (input) => await drive(input),
+    };
+}