@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/akuma/provider-recipe.js

@@ -0,0 +1,100 @@
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function snapshot(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(snapshot));
+    const object = record(value);
+    if (object === null)
+        return value;
+    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
+}
+function optionText(options, field, blank) {
+    const selected = options[field];
+    if (selected === 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;
+}
+export function decodeProviderOptions(value) {
+    const options = record(value);
+    if (options === null)
+        throw new TypeError("provider options must be an object");
+    const allowed = ["effort", "model", "network", "readonly", "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");
+    if (options.readonly !== undefined && options.readonly !== true) {
+        throw new TypeError("provider option readonly must be true");
+    }
+    const network = options.network;
+    if (network !== undefined && network !== "disabled" && network !== "enabled") {
+        throw new TypeError("provider option network must be disabled, enabled");
+    }
+    const systemPrompt = optionText(options, "systemPrompt", "allow");
+    return Object.freeze({
+        ...(model === undefined ? {} : { model }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(options.readonly === undefined ? {} : { readonly: true }),
+        ...(network === undefined ? {} : { network }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }),
+    });
+}
+export function decodeReadonlyRestraint(value) {
+    const restraint = record(value);
+    if (restraint === null)
+        throw new TypeError("readonly restraint must be an object");
+    const keys = Object.keys(restraint).sort();
+    if (restraint.enforcement === "native" && keys.length === 1 && keys[0] === "enforcement") {
+        return Object.freeze({ enforcement: "native" });
+    }
+    if (restraint.enforcement === "none"
+        && keys.length === 2 && keys[0] === "diagnostic" && keys[1] === "enforcement"
+        && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
+        return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
+    }
+    throw new TypeError("readonly restraint must be native or none with a diagnostic");
+}
+function providerKind(value) {
+    return value === "acp" || value === "claude-agent-sdk" || value === "codex-app-server" || value === "grok-build"
+        || value === "opencode-sdk" || value === "pi";
+}
+export function decodeProviderRecipe(input) {
+    const value = record(input);
+    if (value === null)
+        throw new TypeError("provider execution must be an object");
+    const allowed = ["config", "env", "executable", "kind", "name"];
+    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider execution has unknown field ${unknown}`);
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        throw new TypeError("provider execution name must be a nonblank string");
+    }
+    if (!providerKind(value.kind))
+        throw new TypeError("provider execution has unknown kind");
+    if (value.executable !== undefined && (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
+        throw new TypeError("provider execution executable must be a nonblank string");
+    }
+    const config = value.config === undefined ? undefined : record(value.config);
+    if (config === null)
+        throw new TypeError("provider execution config must be an object");
+    const env = value.env === undefined ? undefined : record(value.env);
+    if (env === null)
+        throw new TypeError("provider execution env must be an object");
+    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
+        throw new TypeError("provider execution env must contain only string values");
+    }
+    return Object.freeze({
+        name: value.name,
+        kind: value.kind,
+        ...(value.executable === undefined ? {} : { executable: value.executable }),
+        ...(config === undefined ? {} : { config: snapshot(config) }),
+        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
+    });
+}

package/build/src/akuma/provider.d.ts

@@ -1,17 +1,25 @@
-import type { Confinement, ProviderOptions, ResumeCoordinate } from "./heart/index.js";
-export type { ProviderOptions, ResumeCoordinate } from "./heart/index.js";
+import type { Confinement } from "./heart/index.js";
+import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
+import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
+export type { ResumeCoordinate } from "./coordinate.js";
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export type SearchScope = "content" | "files" | "web";
 export type ToolCall = Readonly<{
     kind: "run";
     command: string;
 }> | Readonly<{
     kind: "read";
     path: string;
+    offset?: number;
+    limit?: number;
 }> | Readonly<{
     kind: "search";
     query: string;
+    scope?: SearchScope;
+    path?: string;
+    glob?: string;
 }> | Readonly<{
     kind: "fileChange";
     changes: readonly Readonly<{
@@ -36,6 +44,7 @@ export type ToolEvent = Readonly<{
     id: string;
     name: string;
     call: ToolCall;
+    truncated?: true;
 }> & (Readonly<{
     phase: "started";
     result?: never;
@@ -49,17 +58,21 @@ export type AgentEvent = Readonly<{
 }> | Readonly<{
     type: "assistant";
     text: string;
+    truncated?: true;
 }> | Readonly<{
     type: "thought";
     text: string;
+    truncated?: true;
 }> | ToolEvent | Readonly<{
     type: "note";
     text: string;
+    truncated?: true;
 }> | Readonly<{
     type: "unknown";
     kind: string;
+    truncated?: true;
 }>;
-export declare function decodeProviderOptions(value: unknown): ProviderOptions;
+export { decodeResumeCoordinate, encodeResumeCoordinate };
 export declare function decodeAgentEvent(value: unknown): AgentEvent;
 export declare function encodeAgentEvent(event: AgentEvent): unknown;
 export declare function boundedEventText(value: string): string;
@@ -81,19 +94,58 @@ export declare class AgentEventChannel implements AsyncIterable<AgentEvent> {
 export type TurnResult = Readonly<{
     kind: "answered";
     answer: string;
-    historyId: string;
+    historyId?: string;
 }> | Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
-export type Drive = Readonly<{
+export type ProviderFence = string;
+export type TellReceipt = Readonly<{
+    evidence: "exact";
+    tellId: string;
+    kind: string;
+}> | Readonly<{
+    evidence: "fence";
+    fence: ProviderFence;
+    kind: string;
+}>;
+export type TellSubmission = Readonly<{
+    kind: "accepted";
+    fence: ProviderFence;
+}> | Readonly<{
+    kind: "turn-ended";
+}>;
+export type Session = Readonly<{
+    admission: Readonly<{
+        fence: ProviderFence;
+    }>;
     events: AsyncIterable<AgentEvent>;
+    receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
+    /** Fulfills after every adapter-owned OS child or native session is disposed. */
     abort(): Promise<void>;
+    tell?(tell: Readonly<{
+        id: string;
+        text: string;
+    }>): Promise<TellSubmission>;
+}>;
+export type DriveInput = Readonly<{
+    body: string;
+    launchTells: readonly Readonly<{
+        id: string;
+        text: string;
+    }>[];
+    cwd: string;
+    options: ProviderOptions;
+    signal: AbortSignal;
+    requests?: Readonly<{
+        dir: string;
+    }>;
 }>;
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";
     options: ProviderOptions;
+    readonly?: ReadonlyRestraint;
 }> | Readonly<{
     kind: "refused";
     diagnostic: string;
@@ -111,13 +163,15 @@ export type ProviderAdapter = Readonly<{
     }>): Promise<Readonly<{
         session: ResumeCoordinate;
     }>>;
-    start(input: Readonly<{
-        prompt: string;
-        cwd: string;
-        options: ProviderOptions;
-        session?: ResumeCoordinate;
-        requests?: Readonly<{
-            dir: string;
+    start(input: DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "fresh";
+        }>;
+    }>): Promise<Session>;
+    resume?(input: DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "resume";
+            coordinate: ResumeCoordinate;
         }>;
-    }>): Promise<Drive>;
+    }>): Promise<Session>;
 }>;

package/build/src/akuma/provider.js

@@ -1,3 +1,4 @@
+import { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
 export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export const AGENT_EVENT_TEXT_LIMIT = 16_384;
 export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
@@ -14,82 +15,111 @@ function object(value) {
         ? value
         : null;
 }
-function optionText(options, field, blank) {
-    const selected = options[field];
-    if (selected === undefined)
+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;
-    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);
@@ -106,27 +136,34 @@ function decodeToolResult(value) {
     };
 }
 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 };
+        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 };
+        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 } : null;
-        case "note": return typeof event.text === "string" ? { type, text: event.text } : null;
-        case "unknown": return typeof event.kind === "string" ? { type, kind: event.kind } : null;
+        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 = object(event.coordinate);
-            return typeof coordinate?.sessionId === "string" ? { type, coordinate: { sessionId: coordinate.sessionId } } : null;
+            const coordinate = decodeResumeCoordinate(event.coordinate);
+            return coordinate === null ? null : { type, coordinate };
         }
         case "tool": return decodeToolEvent(event);
         default: return type;
@@ -143,50 +180,80 @@ export function decodeAgentEvent(value) {
 }
 function boundedToolCall(call) {
     switch (call.kind) {
-        case "run": return { kind: call.kind, command: boundedEventText(call.command) };
-        case "read": return { kind: call.kind, path: boundedEventText(call.path) };
-        case "search": return { kind: call.kind, query: boundedEventText(call.query) };
+        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),
+                ...(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 {
-            kind: call.kind,
-            changes: call.changes.map((change) => ({
-                ...change,
-                path: boundedEventText(change.path),
-            })),
+            value: {
+                kind: call.kind,
+                changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
+            },
+            truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
         };
-        case "other": return { kind: call.kind, display: boundedEventText(call.display) };
+        case "other": return { value: { kind: call.kind, display: boundedEventText(call.display) }, truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT };
         default: return call;
     }
 }
 function boundedToolResult(result) {
     return {
-        status: result.status,
-        ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
-        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        value: {
+            status: result.status,
+            ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
+            ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        },
+        truncated: result.message !== undefined && result.message.length > AGENT_EVENT_TEXT_LIMIT,
     };
 }
 export function encodeAgentEvent(event) {
+    const marked = (value, changed) => ({
+        ...value,
+        ...(changed || ("truncated" in event && event.truncated === true) ? { truncated: true } : {}),
+    });
     switch (event.type) {
-        case "session": return { type: event.type, coordinate: { sessionId: event.coordinate.sessionId } };
-        case "assistant": return { type: event.type, text: boundedEventText(event.text) };
-        case "thought": return { type: event.type, text: boundedThoughtText(event.text) };
-        case "note": return { type: event.type, text: boundedEventText(event.text) };
-        case "unknown": return { type: event.type, kind: boundedEventText(event.kind) };
-        case "tool": return event.phase === "started"
-            ? {
+        case "session": return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
+        case "assistant": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "thought": return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
+        case "note": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "unknown": return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
+        case "tool": {
+            const call = boundedToolCall(event.call);
+            const name = boundedEventText(event.name);
+            const result = event.phase === "completed" ? boundedToolResult(event.result) : undefined;
+            return marked(event.phase === "started" ? {
                 type: event.type,
                 id: event.id,
                 phase: event.phase,
-                name: boundedEventText(event.name),
-                call: boundedToolCall(event.call),
+                name,
+                call: call.value,
             }
-            : {
-                type: event.type,
-                id: event.id,
-                phase: event.phase,
-                name: boundedEventText(event.name),
-                call: boundedToolCall(event.call),
-                result: boundedToolResult(event.result),
-            };
+                : {
+                    type: event.type,
+                    id: event.id,
+                    phase: event.phase,
+                    name,
+                    call: call.value,
+                    result: result.value,
+                }, name !== event.name || call.truncated || result?.truncated === true);
+        }
         default: return event;
     }
 }
@@ -197,7 +264,7 @@ export function boundedThoughtText(value) {
     return value.slice(0, AGENT_THOUGHT_TEXT_LIMIT);
 }
 export function noteEvent(note) {
-    return { type: "note", text: boundedEventText(note.replace(/\s+/g, " ").trim()) };
+    return { type: "note", text: note.replace(/\s+/g, " ").trim() };
 }
 export function unknownEvent(kind) {
     return { type: "unknown", 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 {};