@automatalabs/pi-acp 0.1.0

package/dist/agent.js

@@ -0,0 +1,398 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { AUTH_METHODS, authenticateMethod } from "./auth.js";
+import { adapterError, isRequestError, unexpectedError } from "./errors.js";
+import { bridgeMcpServers, disposeMcpBridge, } from "./mcp-bridge.js";
+import { PiSession } from "./session.js";
+import { StructuredOutputState, STRUCTURED_TOOL_NAME } from "./structured-output.js";
+export const PKG_VERSION = String(JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);
+function validateCwd(cwd) {
+    if (!isAbsolute(cwd))
+        throw adapterError("invalid_cwd");
+    try {
+        if (!statSync(cwd).isDirectory())
+            throw adapterError("invalid_cwd");
+    }
+    catch (error) {
+        if (isRequestError(error))
+            throw error;
+        throw adapterError("invalid_cwd");
+    }
+}
+function openSignal(requestSignal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(requestSignal.reason);
+    if (requestSignal.aborted)
+        abort();
+    else
+        requestSignal.addEventListener("abort", abort, { once: true });
+    return controller;
+}
+export class PiAcpAgent {
+    deps;
+    live = new Map();
+    opening = new Map();
+    openingControllers = new Set();
+    openingTasks = new Set();
+    tombstones = new Set();
+    disposed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    initialize(_context) {
+        return {
+            protocolVersion: 1,
+            agentInfo: {
+                name: "@automatalabs/pi-acp",
+                title: "pi coding agent",
+                version: PKG_VERSION,
+            },
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: { image: true },
+                mcpCapabilities: {},
+                sessionCapabilities: { resume: {}, fork: {}, list: {}, close: {} },
+                _meta: { "@automatalabs/pi-acp": { outputSchema: true } },
+            },
+            authMethods: AUTH_METHODS,
+        };
+    }
+    authenticate(context) {
+        return authenticateMethod(context.params.methodId);
+    }
+    ensureMayOpen(id) {
+        if (this.disposed)
+            throw adapterError("internal_error");
+        if (this.tombstones.has(id))
+            throw adapterError("session_terminated");
+        if (this.live.has(id) || this.opening.has(id))
+            throw adapterError("session_already_open");
+    }
+    reserve(id, controller) {
+        this.ensureMayOpen(id);
+        this.opening.set(id, controller);
+    }
+    beginOpening(requestSignal) {
+        if (this.disposed)
+            throw adapterError("internal_error");
+        const controller = openSignal(requestSignal);
+        this.openingControllers.add(controller);
+        return { controller };
+    }
+    track(task) {
+        this.openingTasks.add(task);
+        task.finally(() => this.openingTasks.delete(task)).catch(() => undefined);
+        return task;
+    }
+    gate(opening) {
+        opening.controller.signal.throwIfAborted();
+        if (this.disposed || (opening.id !== undefined && this.tombstones.has(opening.id))) {
+            throw opening.controller.signal.reason ?? adapterError("internal_error");
+        }
+    }
+    async construct(opening, manager, cwd, client, mcpServers, replay, preconnected) {
+        const id = manager.getSessionId();
+        if (opening.id === undefined) {
+            this.reserve(id, opening.controller);
+            opening.id = id;
+        }
+        let bridge = preconnected;
+        let pi;
+        let wrapper;
+        try {
+            this.gate(opening);
+            bridge ??= await bridgeMcpServers(mcpServers, opening.controller.signal, this.deps);
+            this.gate(opening);
+            const structured = new StructuredOutputState();
+            const created = await this.deps.createAgentSession({
+                cwd,
+                sessionManager: manager,
+                modelRuntime: this.deps.modelRuntime,
+                customTools: [...bridge.tools, structured.tool],
+            });
+            pi = created.session;
+            this.gate(opening);
+            wrapper = new PiSession({
+                sessionId: id,
+                session: pi,
+                manager,
+                client,
+                deps: this.deps,
+                mcpClients: bridge.clients,
+                failedMcpResults: bridge.failedResults,
+                structured,
+                onWedged: (sessionId, session) => this.terminateWedged(sessionId, session),
+            });
+            structured.install(pi);
+            const names = new Set(pi.getAllTools().map(({ name }) => name));
+            if (!names.has(STRUCTURED_TOOL_NAME))
+                throw adapterError("structured_tool_collision");
+            const missingAlias = bridge.aliases.find((alias) => !names.has(alias));
+            if (missingAlias) {
+                throw adapterError("mcp_init_error", {
+                    server: bridge.aliasServers.get(missingAlias) ?? "unknown",
+                });
+            }
+            if (replay)
+                await wrapper.replay(manager.getBranch());
+            this.gate(opening);
+            this.live.set(id, wrapper);
+            this.opening.delete(id);
+            return wrapper;
+        }
+        catch (error) {
+            if (wrapper)
+                await wrapper.disposeResources();
+            else {
+                if (pi) {
+                    try {
+                        await pi.dispose();
+                    }
+                    catch (disposeError) {
+                        console.error("pi-acp rollback dispose error:", disposeError);
+                    }
+                }
+                if (bridge)
+                    await disposeMcpBridge(bridge.clients, this.deps);
+            }
+            throw error;
+        }
+        finally {
+            if (opening.id !== undefined && this.opening.get(opening.id) === opening.controller) {
+                this.opening.delete(opening.id);
+            }
+            this.openingControllers.delete(opening.controller);
+        }
+    }
+    openingError(error) {
+        if (isRequestError(error))
+            throw error;
+        throw unexpectedError(error);
+    }
+    newSession(context) {
+        validateCwd(context.params.cwd);
+        let manager;
+        try {
+            manager = this.deps.sessions.create(context.params.cwd, this.deps.sessionDir);
+        }
+        catch (error) {
+            return this.openingError(error);
+        }
+        const opening = this.beginOpening(context.signal);
+        try {
+            this.reserve(manager.getSessionId(), opening.controller);
+            opening.id = manager.getSessionId();
+        }
+        catch (error) {
+            this.openingControllers.delete(opening.controller);
+            throw error;
+        }
+        const task = this.construct(opening, manager, context.params.cwd, context.client, context.params.mcpServers, false).then((session) => ({ sessionId: session.sessionId, configOptions: session.configOptions(), modes: null }))
+            .catch((error) => this.openingError(error));
+        return this.track(task);
+    }
+    reattach(context, replay) {
+        validateCwd(context.params.cwd);
+        const opening = this.beginOpening(context.signal);
+        try {
+            this.reserve(context.params.sessionId, opening.controller);
+            opening.id = context.params.sessionId;
+        }
+        catch (error) {
+            this.openingControllers.delete(opening.controller);
+            throw error;
+        }
+        const task = (async () => {
+            try {
+                this.gate(opening);
+                const infos = await this.deps.sessions.list(context.params.cwd, this.deps.sessionDir);
+                this.gate(opening);
+                const info = infos.find(({ id }) => id === context.params.sessionId);
+                if (!info)
+                    throw adapterError("unknown_session");
+                let manager;
+                try {
+                    manager = this.deps.sessions.open(info.path, this.deps.sessionDir);
+                }
+                catch {
+                    throw adapterError("session_corrupt");
+                }
+                const session = await this.construct(opening, manager, context.params.cwd, context.client, context.params.mcpServers ?? [], replay);
+                return { configOptions: session.configOptions(), modes: null };
+            }
+            catch (error) {
+                if (opening.id !== undefined && this.opening.get(opening.id) === opening.controller) {
+                    this.opening.delete(opening.id);
+                }
+                this.openingControllers.delete(opening.controller);
+                return this.openingError(error);
+            }
+        })();
+        return this.track(task);
+    }
+    loadSession(context) {
+        return this.reattach(context, true);
+    }
+    resumeSession(context) {
+        return this.reattach(context, false);
+    }
+    forkSession(context) {
+        if (this.tombstones.has(context.params.sessionId))
+            throw adapterError("session_terminated");
+        const liveSource = this.live.get(context.params.sessionId);
+        if (liveSource?.busy)
+            throw adapterError("session_busy");
+        validateCwd(context.params.cwd);
+        const opening = this.beginOpening(context.signal);
+        const task = (async () => {
+            let bridge;
+            try {
+                let sourcePath;
+                if (liveSource) {
+                    sourcePath = liveSource.manager.getSessionFile();
+                    if (!sourcePath || !existsSync(sourcePath))
+                        throw adapterError("session_not_forkable");
+                }
+                else {
+                    const all = await this.deps.sessions.listAll(this.deps.sessionDir);
+                    sourcePath = all.find(({ id }) => id === context.params.sessionId)?.path;
+                    if (!sourcePath)
+                        throw adapterError("unknown_session");
+                }
+                this.gate(opening);
+                bridge = await bridgeMcpServers(context.params.mcpServers ?? [], opening.controller.signal, this.deps);
+                this.gate(opening);
+                if (this.tombstones.has(context.params.sessionId))
+                    throw adapterError("session_terminated");
+                if (liveSource?.busy)
+                    throw adapterError("session_busy");
+                let manager;
+                try {
+                    manager = this.deps.sessions.forkFrom(sourcePath, context.params.cwd, this.deps.sessionDir);
+                }
+                catch {
+                    throw adapterError("session_corrupt");
+                }
+                this.reserve(manager.getSessionId(), opening.controller);
+                opening.id = manager.getSessionId();
+                const session = await this.construct(opening, manager, context.params.cwd, context.client, context.params.mcpServers ?? [], false, bridge);
+                bridge = undefined;
+                return { sessionId: session.sessionId, configOptions: session.configOptions(), modes: null };
+            }
+            catch (error) {
+                if (bridge)
+                    await disposeMcpBridge(bridge.clients, this.deps);
+                if (opening.id !== undefined && this.opening.get(opening.id) === opening.controller) {
+                    this.opening.delete(opening.id);
+                }
+                this.openingControllers.delete(opening.controller);
+                return this.openingError(error);
+            }
+        })();
+        return this.track(task);
+    }
+    async listSessions(context) {
+        if (context.params.cwd !== undefined && context.params.cwd !== null)
+            validateCwd(context.params.cwd);
+        let offset = 0;
+        const cursor = context.params.cursor;
+        if (cursor) {
+            try {
+                const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+                if (!/^(0|[1-9][0-9]*)$/.test(decoded))
+                    throw new Error("noncanonical decimal");
+                if (Buffer.from(decoded).toString("base64url") !== cursor)
+                    throw new Error("noncanonical base64url");
+                const value = BigInt(decoded);
+                offset = value > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(value);
+            }
+            catch {
+                throw adapterError("invalid_cursor");
+            }
+        }
+        let infos;
+        try {
+            infos = context.params.cwd
+                ? await this.deps.sessions.list(context.params.cwd, this.deps.sessionDir)
+                : await this.deps.sessions.listAll(this.deps.sessionDir);
+        }
+        catch (error) {
+            throw unexpectedError(error);
+        }
+        const page = infos.slice(offset, offset + 100);
+        const nextOffset = offset + 100;
+        return {
+            sessions: page.map((info) => ({
+                sessionId: info.id,
+                cwd: info.cwd,
+                title: info.name ?? info.firstMessage,
+            })),
+            ...(nextOffset < infos.length
+                ? { nextCursor: Buffer.from(String(nextOffset)).toString("base64url") }
+                : {}),
+        };
+    }
+    async closeSession(context) {
+        const controller = this.opening.get(context.params.sessionId);
+        if (controller) {
+            controller.abort(new Error("session closed while opening"));
+            return {};
+        }
+        const session = this.live.get(context.params.sessionId);
+        if (!session)
+            return {};
+        try {
+            await session.dispose();
+        }
+        catch (error) {
+            console.error("pi-acp close error:", error);
+        }
+        finally {
+            if (this.live.get(context.params.sessionId) === session)
+                this.live.delete(context.params.sessionId);
+        }
+        return {};
+    }
+    requireLive(id) {
+        if (this.tombstones.has(id))
+            throw adapterError("session_terminated");
+        const session = this.live.get(id);
+        if (!session)
+            throw adapterError("unknown_session");
+        return session;
+    }
+    setConfigOption(context) {
+        const session = this.requireLive(context.params.sessionId);
+        return session.setConfig(context.params.configId, context.params.value)
+            .then((configOptions) => ({ configOptions }))
+            .catch((error) => {
+            if (isRequestError(error))
+                throw error;
+            throw unexpectedError(error);
+        });
+    }
+    prompt(context) {
+        return this.requireLive(context.params.sessionId).prompt(context.params, context.signal);
+    }
+    cancel(context) {
+        this.live.get(context.params.sessionId)?.cancel();
+    }
+    async terminateWedged(id, session) {
+        this.tombstones.add(id);
+        if (this.live.get(id) === session)
+            this.live.delete(id);
+        await session.disposeResources();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const controller of this.openingControllers)
+            controller.abort(new Error("agent disposed"));
+        await Promise.allSettled([...this.openingTasks]);
+        const sessions = [...this.live.values()];
+        this.live.clear();
+        await Promise.allSettled(sessions.map((session) => session.dispose()));
+        this.tombstones.clear();
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,4 @@
+import type { AuthMethod } from "@agentclientprotocol/sdk";
+export declare const AUTH_METHODS: AuthMethod[];
+export declare function authenticateMethod(methodId: string): Record<string, never>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAG3D,eAAO,MAAM,YAAY,EAAE,UAAU,EAgCpC,CAAC;AAIF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAG1E"}

package/dist/auth.js

@@ -0,0 +1,40 @@
+import { adapterError } from "./errors.js";
+export const AUTH_METHODS = [
+    {
+        id: "anthropic-api-key",
+        name: "Anthropic API key",
+        type: "env_var",
+        vars: [{ name: "ANTHROPIC_API_KEY", secret: true }],
+    },
+    {
+        id: "openai-api-key",
+        name: "OpenAI API key",
+        type: "env_var",
+        vars: [{ name: "OPENAI_API_KEY", secret: true }],
+    },
+    {
+        id: "gemini-api-key",
+        name: "Google Gemini API key",
+        type: "env_var",
+        vars: [{ name: "GEMINI_API_KEY", secret: true }],
+    },
+    {
+        id: "xai-api-key",
+        name: "xAI API key",
+        type: "env_var",
+        vars: [{ name: "XAI_API_KEY", secret: true }],
+    },
+    {
+        id: "openrouter-api-key",
+        name: "OpenRouter API key",
+        type: "env_var",
+        vars: [{ name: "OPENROUTER_API_KEY", secret: true }],
+    },
+    { id: "pi-stored-credentials", name: "pi stored credentials" },
+];
+const IDS = new Set(AUTH_METHODS.map(({ id }) => id));
+export function authenticateMethod(methodId) {
+    if (!IDS.has(methodId))
+        throw adapterError("unknown_auth_method");
+    return {};
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import type { SessionConfigOption } from "@agentclientprotocol/sdk";
+import type { AgentSession, ModelRuntime } from "@earendil-works/pi-coding-agent";
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+export declare function thinkingLevelOption(session: AgentSession): SessionConfigOption;
+export declare function applyConfig(session: AgentSession, modelRuntime: ModelRuntime, configId: string, value: string | boolean): Promise<SessionConfigOption[]>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAGlF,eAAO,MAAM,eAAe,sEAAuE,CAAC;AACpG,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,mBAAmB,CAS9E;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA4BhC"}

package/dist/config.js

@@ -0,0 +1,46 @@
+import { adapterError } from "./errors.js";
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export function thinkingLevelOption(session) {
+    return {
+        id: "thinkingLevel",
+        name: "Thinking level",
+        type: "select",
+        category: "thought_level",
+        currentValue: session.thinkingLevel,
+        options: THINKING_LEVELS.map((value) => ({ value, name: value })),
+    };
+}
+export async function applyConfig(session, modelRuntime, configId, value) {
+    if (configId !== "thinkingLevel" && configId !== "model") {
+        throw adapterError("unknown_config_option");
+    }
+    if (typeof value !== "string")
+        throw adapterError("invalid_config_type");
+    if (configId === "thinkingLevel") {
+        if (!THINKING_LEVELS.includes(value)) {
+            throw adapterError("invalid_config_value");
+        }
+        session.setThinkingLevel(value);
+        return [thinkingLevelOption(session)];
+    }
+    const separator = value.indexOf("/");
+    if (separator <= 0 || separator === value.length - 1)
+        throw adapterError("invalid_model");
+    const provider = value.slice(0, separator);
+    const modelId = value.slice(separator + 1);
+    const model = modelRuntime.getModel(provider, modelId);
+    if (!model)
+        throw adapterError("invalid_model");
+    if (!modelRuntime.hasConfiguredAuth(model.provider))
+        throw adapterError("auth_error");
+    try {
+        await session.setModel(model);
+    }
+    catch (error) {
+        if (error instanceof Error && /^no api key for /i.test(error.message)) {
+            throw adapterError("auth_error");
+        }
+        throw error;
+    }
+    return [thinkingLevelOption(session)];
+}

package/dist/deps.d.ts

@@ -0,0 +1,22 @@
+import { ModelRuntime, SessionManager, type CreateAgentSessionOptions, type CreateAgentSessionResult, type NewSessionOptions, type SessionInfo } from "@earendil-works/pi-coding-agent";
+import type { McpServerStdio } from "@agentclientprotocol/sdk";
+import { type McpClientHandle } from "./mcp-bridge.js";
+export interface PiAcpDeps {
+    createAgentSession(opts: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;
+    sessions: {
+        create(cwd: string, sessionDir?: string, options?: NewSessionOptions): SessionManager;
+        open(path: string, sessionDir?: string, cwdOverride?: string): SessionManager;
+        forkFrom(sourcePath: string, targetCwd: string, sessionDir?: string, options?: NewSessionOptions): SessionManager;
+        list(cwd: string, sessionDir?: string): Promise<SessionInfo[]>;
+        listAll(sessionDir?: string): Promise<SessionInfo[]>;
+    };
+    modelRuntime: ModelRuntime;
+    sessionDir?: string;
+    connectMcpClient(server: McpServerStdio, signal: AbortSignal): Promise<McpClientHandle>;
+    sleep(ms: number, signal: AbortSignal): Promise<void>;
+    graceMs: number;
+    mcpTimeoutMs: number;
+}
+export declare function realSleep(ms: number, signal: AbortSignal): Promise<void>;
+export declare function resolveDeps(partial?: Partial<PiAcpDeps>): Promise<PiAcpDeps>;
+//# sourceMappingURL=deps.d.ts.map

package/dist/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../src/deps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EAEd,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,WAAW,EACjB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvF,QAAQ,EAAE;QACR,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QACtF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;QAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;QAClH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/D,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;KACtD,CAAC;IACF,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IACxF,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxE;AAED,wBAAsB,WAAW,CAAC,OAAO,GAAE,OAAO,CAAC,SAAS,CAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAuBtF"}

package/dist/deps.js

@@ -0,0 +1,39 @@
+import { ModelRuntime, SessionManager, createAgentSession, } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { connectDefaultMcpClient } from "./mcp-bridge.js";
+export function realSleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}
+export async function resolveDeps(partial = {}) {
+    const sleep = partial.sleep ?? realSleep;
+    const mcpTimeoutMs = partial.mcpTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    const modelRuntime = partial.modelRuntime ?? await ModelRuntime.create();
+    const sessions = partial.sessions ?? {
+        create: SessionManager.create,
+        open: SessionManager.open,
+        forkFrom: SessionManager.forkFrom,
+        list: SessionManager.list,
+        listAll: (sessionDir) => SessionManager.listAll(sessionDir),
+    };
+    return {
+        createAgentSession: partial.createAgentSession ?? createAgentSession,
+        sessions,
+        modelRuntime,
+        sessionDir: partial.sessionDir,
+        sleep,
+        graceMs: partial.graceMs ?? 5_000,
+        mcpTimeoutMs,
+        connectMcpClient: partial.connectMcpClient ??
+            ((server, signal) => connectDefaultMcpClient(server, signal, mcpTimeoutMs, sleep)),
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,34 @@
+import { RequestError } from "@agentclientprotocol/sdk";
+export type ErrorKind = "auth_error" | "rate_limit" | "billing_error" | "provider_error" | "invalid_model" | "empty_prompt" | "session_busy" | "invalid_config_value" | "invalid_config_type" | "unknown_config_option" | "invalid_cwd" | "unknown_session" | "session_already_open" | "session_terminated" | "session_corrupt" | "session_not_forkable" | "mcp_init_error" | "unsupported_mcp_transport" | "structured_tool_collision" | "invalid_output_schema" | "invalid_cursor" | "unknown_auth_method" | "notification_error" | "internal_error";
+export interface DiagnosticLike {
+    type: string;
+    timestamp: number;
+    error?: {
+        name?: string;
+        message: string;
+        stack?: string;
+        code?: string | number;
+    };
+    details?: unknown;
+}
+export interface TerminalAssistantLike {
+    stopReason: string;
+    errorMessage?: string;
+    diagnostics?: DiagnosticLike[];
+}
+export declare function redactedDiagnostics(diagnostics: readonly DiagnosticLike[] | undefined): {
+    type: string;
+    timestamp: number;
+}[] | undefined;
+export declare function adapterError(kind: ErrorKind, extras?: {
+    server?: string;
+    details?: Array<{
+        type: string;
+        timestamp: number;
+    }>;
+}): RequestError;
+export declare function classifyPreflight(error: unknown): RequestError;
+export declare function classifyTerminal(message: TerminalAssistantLike): RequestError;
+export declare function unexpectedError(error: unknown, terminal?: TerminalAssistantLike): RequestError;
+export declare function isRequestError(error: unknown): error is RequestError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,cAAc,GACd,sBAAsB,GACtB,qBAAqB,GACrB,uBAAuB,GACvB,aAAa,GACb,iBAAiB,GACjB,sBAAsB,GACtB,oBAAoB,GACpB,iBAAiB,GACjB,sBAAsB,GACtB,gBAAgB,GAChB,2BAA2B,GAC3B,2BAA2B,GAC3B,uBAAuB,GACvB,gBAAgB,GAChB,qBAAqB,GACrB,oBAAoB,GACpB,gBAAgB,CAAC;AA+CrB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACnF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,GAAG,SAAS;;;gBAIrF;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,EACf,MAAM,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAO,GACrF,YAAY,CAOd;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAW9D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,qBAAqB,GAAG,YAAY,CAsB7E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,qBAAqB,GAAG,YAAY,CAK9F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE"}