@automatalabs/pi-acp 0.1.0

package/dist/replay.js

@@ -0,0 +1,101 @@
+import { mapKind, toContent } from "./translate.js";
+function blocks(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return (content ?? []).map((item) => item.type === "text"
+        ? { type: "text", text: item.text }
+        : { type: "image", data: item.data, mimeType: item.mimeType });
+}
+function bashExecutionToText(message) {
+    let text = `Ran \`${message.command ?? ""}\`\n`;
+    text += message.output ? `\`\`\`\n${message.output}\n\`\`\`` : "(no output)";
+    if (message.cancelled)
+        text += "\n\n(command cancelled)";
+    else if (message.exitCode !== null && message.exitCode !== undefined && message.exitCode !== 0) {
+        text += `\n\nCommand exited with code ${message.exitCode}`;
+    }
+    if (message.truncated && message.fullOutputPath) {
+        text += `\n\n[Output truncated. Full output: ${message.fullOutputPath}]`;
+    }
+    return text;
+}
+function replayMessage(message) {
+    switch (message.role) {
+        case "user":
+            return blocks(message.content).map((content) => ({
+                sessionUpdate: "user_message_chunk",
+                content,
+            }));
+        case "assistant": {
+            const updates = [];
+            for (const item of (message.content ?? [])) {
+                if (item.type === "text") {
+                    updates.push({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: item.text } });
+                }
+                else if (item.type === "thinking") {
+                    updates.push({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: item.thinking } });
+                }
+                else if (item.type === "toolCall") {
+                    updates.push({
+                        sessionUpdate: "tool_call",
+                        toolCallId: item.id,
+                        title: item.name,
+                        kind: mapKind(item.name),
+                        status: "pending",
+                        rawInput: item.arguments,
+                        _meta: { toolName: item.name },
+                    });
+                }
+            }
+            return updates;
+        }
+        case "toolResult": {
+            const update = {
+                sessionUpdate: "tool_call_update",
+                toolCallId: message.toolCallId ?? "",
+                status: message.isError ? "failed" : "completed",
+                content: toContent({ content: message.content }),
+            };
+            if (message.details !== undefined)
+                update.rawOutput = message.details;
+            return [update];
+        }
+        case "bashExecution":
+            return [{ sessionUpdate: "agent_message_chunk", content: { type: "text", text: bashExecutionToText(message) } }];
+        case "custom":
+            return message.display
+                ? blocks(message.content).map((content) => ({
+                    sessionUpdate: "agent_message_chunk",
+                    content,
+                }))
+                : [];
+        case "branchSummary":
+        case "compactionSummary":
+            return [];
+    }
+}
+export function replayEntry(entry) {
+    switch (entry.type) {
+        case "message":
+            return replayMessage(entry.message);
+        case "custom_message":
+            return entry.display
+                ? blocks(entry.content).map((content) => ({
+                    sessionUpdate: "user_message_chunk",
+                    content,
+                }))
+                : [];
+        case "thinking_level_change":
+        case "model_change":
+        case "compaction":
+        case "branch_summary":
+        case "custom":
+        case "label":
+        case "session_info":
+            return [];
+        default: {
+            const exhaustive = entry;
+            return exhaustive;
+        }
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import { type Stream } from "@agentclientprotocol/sdk";
+import { PiAcpAgent } from "./agent.js";
+import { type PiAcpDeps } from "./deps.js";
+export { PiAcpAgent } from "./agent.js";
+export interface RunAcpOptions {
+    deps?: Partial<PiAcpDeps>;
+    stream?: Stream;
+}
+export declare function runAcp(options?: RunAcpOptions): Promise<{
+    connection: import("@agentclientprotocol/sdk").AgentConnection;
+    agent: PiAcpAgent;
+}>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,MAAM,EACZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB;;;GAoBvD"}

package/dist/server.js

@@ -0,0 +1,23 @@
+import { Readable, Writable } from "node:stream";
+import { agent as acpAgent, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { PiAcpAgent } from "./agent.js";
+import { resolveDeps } from "./deps.js";
+export { PiAcpAgent } from "./agent.js";
+export async function runAcp(options = {}) {
+    const impl = new PiAcpAgent(await resolveDeps(options.deps));
+    const app = acpAgent({ name: "@automatalabs/pi-acp" })
+        .onRequest(methods.agent.initialize, (context) => impl.initialize(context))
+        .onRequest(methods.agent.authenticate, (context) => impl.authenticate(context))
+        .onRequest(methods.agent.session.new, (context) => impl.newSession(context))
+        .onRequest(methods.agent.session.load, (context) => impl.loadSession(context))
+        .onRequest(methods.agent.session.resume, (context) => impl.resumeSession(context))
+        .onRequest(methods.agent.session.fork, (context) => impl.forkSession(context))
+        .onRequest(methods.agent.session.list, (context) => impl.listSessions(context))
+        .onRequest(methods.agent.session.close, (context) => impl.closeSession(context))
+        .onRequest(methods.agent.session.setConfigOption, (context) => impl.setConfigOption(context))
+        .onRequest(methods.agent.session.prompt, (context) => impl.prompt(context))
+        .onNotification(methods.agent.session.cancel, (context) => impl.cancel(context));
+    const stream = options.stream ?? ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+    const connection = app.connect(stream);
+    return { connection, agent: impl };
+}

package/dist/session.d.ts

@@ -0,0 +1,58 @@
+import { type AgentContext, type PromptRequest, type PromptResponse, type SessionUpdate } from "@agentclientprotocol/sdk";
+import type { AgentSession, SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
+import type { PiAcpDeps } from "./deps.js";
+import { StructuredOutputState } from "./structured-output.js";
+import { type McpClientHandle, type McpResultProjection } from "./mcp-bridge.js";
+export interface PiSessionOptions {
+    sessionId: string;
+    session: AgentSession;
+    manager: SessionManager;
+    client: AgentContext;
+    deps: PiAcpDeps;
+    mcpClients: McpClientHandle[];
+    failedMcpResults: Map<string, McpResultProjection>;
+    structured: StructuredOutputState;
+    onWedged(sessionId: string, session: PiSession): Promise<void>;
+}
+export declare class PiSession {
+    readonly sessionId: string;
+    readonly pi: AgentSession;
+    readonly manager: SessionManager;
+    private readonly client;
+    private readonly deps;
+    private readonly mcpClients;
+    private readonly failedMcpResults;
+    private readonly structured;
+    private readonly onWedged;
+    private readonly pending;
+    private pump;
+    private pumpFailure;
+    private stopped;
+    private closing;
+    private disposed;
+    private unsubscribe;
+    private activeTurn;
+    constructor(options: PiSessionOptions);
+    get busy(): boolean;
+    configOptions(): import("@agentclientprotocol/sdk").SessionConfigOption[];
+    enqueue(update: SessionUpdate): void;
+    private startPump;
+    drain(): Promise<void>;
+    replay(entries: readonly SessionEntry[]): Promise<void>;
+    setConfig(configId: string, value: string | boolean): Promise<import("@agentclientprotocol/sdk").SessionConfigOption[]>;
+    private disarm;
+    private finish;
+    private notificationFailure;
+    private abortTurn;
+    private turnError;
+    private runTurnTask;
+    private cleanupWedged;
+    private startBackstop;
+    private handlePiResolved;
+    private handlePiRejected;
+    prompt(params: PromptRequest, requestSignal: AbortSignal): Promise<PromptResponse>;
+    cancel(): void;
+    dispose(): Promise<void>;
+    disposeResources(): Promise<void>;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAElG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAK3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAS/D,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAC;AAiBzB,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACnD,UAAU,EAAE,qBAAqB,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAED,qBAAa,SAAS;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAY;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmC;IACpE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IACxD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,UAAU,CAAyB;gBAE/B,OAAO,EAAE,gBAAgB;IAqCrC,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,aAAa;IAIb,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMpC,OAAO,CAAC,SAAS;IAwBX,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,MAAM,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvD,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAKzD,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,WAAW;YAOL,aAAa;IAQ3B,OAAO,CAAC,aAAa;YAqCP,gBAAgB;YAsBhB,gBAAgB;IAiBxB,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC;IAsFxF,MAAM,IAAI,IAAI;IAIR,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAWxB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;CAwBxC"}

package/dist/session.js

@@ -0,0 +1,414 @@
+import { methods, } from "@agentclientprotocol/sdk";
+import { adapterError, classifyPreflight, isRequestError, unexpectedError } from "./errors.js";
+import { applyConfig, thinkingLevelOption } from "./config.js";
+import { convertPromptContent } from "./prompt-content.js";
+import { replayEntry } from "./replay.js";
+import { stopReasonFor } from "./stop-reason.js";
+import { translateEvent } from "./translate.js";
+import { agentMessages, promptUsage, terminalAssistant, usageUpdate, } from "./usage.js";
+import { installPermissionWrapper } from "./permissions.js";
+import { disposeMcpBridge, } from "./mcp-bridge.js";
+export class PiSession {
+    sessionId;
+    pi;
+    manager;
+    client;
+    deps;
+    mcpClients;
+    failedMcpResults;
+    structured;
+    onWedged;
+    pending = [];
+    pump;
+    pumpFailure;
+    stopped = false;
+    closing = false;
+    disposed = false;
+    unsubscribe;
+    activeTurn;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.pi = options.session;
+        this.manager = options.manager;
+        this.client = options.client;
+        this.deps = options.deps;
+        this.mcpClients = options.mcpClients;
+        this.failedMcpResults = options.failedMcpResults;
+        this.structured = options.structured;
+        this.onWedged = options.onWedged;
+        installPermissionWrapper(this.pi, {
+            sessionId: this.sessionId,
+            client: this.client,
+            drain: () => this.drain(),
+            turnSignal: () => this.activeTurn?.controller.signal,
+        });
+        const innerAfterToolCall = this.pi.agent.afterToolCall;
+        this.pi.agent.afterToolCall = async (context, signal) => {
+            const innerResult = innerAfterToolCall ? await innerAfterToolCall(context, signal) : undefined;
+            const failedResult = this.failedMcpResults.get(context.toolCall.id);
+            if (!failedResult)
+                return innerResult;
+            return {
+                ...innerResult,
+                content: failedResult.content,
+                ...(failedResult.details === undefined ? {} : { details: failedResult.details }),
+                isError: true,
+            };
+        };
+        this.unsubscribe = this.pi.subscribe((event) => {
+            const failedResult = event.type === "tool_execution_end" && event.isError
+                ? this.failedMcpResults.get(event.toolCallId)
+                : undefined;
+            if (event.type === "tool_execution_end")
+                this.failedMcpResults.delete(event.toolCallId);
+            for (const update of translateEvent(event, failedResult))
+                this.enqueue(update);
+        });
+    }
+    get busy() {
+        return this.activeTurn !== undefined || this.closing;
+    }
+    configOptions() {
+        return [thinkingLevelOption(this.pi)];
+    }
+    enqueue(update) {
+        if (this.stopped)
+            return;
+        this.pending.push(update);
+        if (!this.pump)
+            this.startPump();
+    }
+    startPump() {
+        this.pump = (async () => {
+            while (!this.stopped && this.pending.length > 0) {
+                const update = this.pending.shift();
+                if (!update)
+                    continue;
+                await this.client.notify(methods.client.session.update, {
+                    sessionId: this.sessionId,
+                    update,
+                });
+            }
+        })()
+            .catch((error) => {
+            this.pumpFailure = error;
+            this.stopped = true;
+            this.pending.length = 0;
+            this.notificationFailure();
+            throw error;
+        })
+            .finally(() => {
+            this.pump = undefined;
+        });
+        this.pump.catch(() => undefined);
+    }
+    async drain() {
+        if (this.pumpFailure !== undefined)
+            throw this.pumpFailure;
+        while (this.pump)
+            await this.pump;
+        if (this.pumpFailure !== undefined)
+            throw this.pumpFailure;
+    }
+    async replay(entries) {
+        for (const entry of entries) {
+            for (const update of replayEntry(entry))
+                this.enqueue(update);
+        }
+        try {
+            await this.drain();
+        }
+        catch {
+            throw adapterError("notification_error");
+        }
+    }
+    async setConfig(configId, value) {
+        if (this.busy)
+            throw adapterError("session_busy");
+        return applyConfig(this.pi, this.deps.modelRuntime, configId, value);
+    }
+    disarm(turn) {
+        if (!turn.structured)
+            return;
+        try {
+            this.structured.disarm(this.pi);
+        }
+        catch (error) {
+            console.error("pi-acp structured-output disarm error:", error);
+        }
+    }
+    finish(turn, outcome, keepBackstop = false) {
+        if (turn.completed)
+            return;
+        turn.completed = true;
+        turn.removeRequestAbort?.();
+        turn.removeRequestAbort = undefined;
+        this.disarm(turn);
+        if (!keepBackstop)
+            turn.settledController.abort();
+        if (this.activeTurn === turn)
+            this.activeTurn = undefined;
+        if ("response" in outcome)
+            turn.resolve(outcome.response);
+        else
+            turn.reject(outcome.error);
+        turn.resolveSettlement();
+    }
+    notificationFailure() {
+        const turn = this.activeTurn;
+        if (!turn || turn.completed)
+            return;
+        turn.notificationFailed = true;
+        this.abortTurn(turn);
+        this.finish(turn, { error: adapterError("notification_error") }, true);
+    }
+    abortTurn(turn) {
+        if (turn.completed)
+            return;
+        if (!turn.controller.signal.aborted)
+            turn.controller.abort();
+    }
+    turnError(turn, error) {
+        if (turn.completed)
+            return;
+        let terminal;
+        try {
+            terminal = terminalAssistant(agentMessages(this.pi).slice(turn.startMessageIndex));
+        }
+        catch {
+            terminal = undefined;
+        }
+        this.finish(turn, { error: isRequestError(error) ? error : unexpectedError(error, terminal) });
+    }
+    runTurnTask(turn, task) {
+        void task.catch((error) => {
+            if (turn.completed)
+                console.error("pi-acp detached turn error:", error);
+            else
+                this.turnError(turn, error);
+        });
+    }
+    async cleanupWedged() {
+        try {
+            await this.onWedged(this.sessionId, this);
+        }
+        catch (error) {
+            console.error("pi-acp wedged-session cleanup error:", error);
+        }
+    }
+    startBackstop(turn) {
+        if (turn.backstopStarted)
+            return;
+        turn.backstopStarted = true;
+        const backstop = this.deps.sleep(this.deps.graceMs, turn.settledController.signal).then(async () => {
+            try {
+                if (!turn.completed) {
+                    const messages = agentMessages(this.pi).slice(turn.startMessageIndex);
+                    if (!this.pumpFailure) {
+                        this.enqueue(usageUpdate(this.pi));
+                        await this.drain();
+                    }
+                    if (!turn.completed) {
+                        this.finish(turn, {
+                            response: { stopReason: "cancelled", usage: promptUsage(messages) },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.pumpFailure !== undefined) {
+                    turn.notificationFailed = true;
+                    this.finish(turn, { error: adapterError("notification_error") }, true);
+                }
+                else {
+                    this.turnError(turn, error);
+                }
+            }
+            if (turn.completed)
+                await this.cleanupWedged();
+        }, async (error) => {
+            if (turn.settledController.signal.aborted || turn.completed)
+                return;
+            this.turnError(turn, error);
+            await this.cleanupWedged();
+        });
+        this.runTurnTask(turn, backstop);
+    }
+    async handlePiResolved(turn) {
+        if (turn.completed)
+            return;
+        try {
+            const messages = agentMessages(this.pi).slice(turn.startMessageIndex);
+            if (turn.structured) {
+                const json = this.structured.takeJson();
+                if (json !== undefined) {
+                    this.enqueue({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: json } });
+                }
+            }
+            this.enqueue(usageUpdate(this.pi));
+            await this.drain();
+            if (turn.completed)
+                return;
+            const terminal = terminalAssistant(messages);
+            const stopReason = stopReasonFor(terminal, turn.controller.signal.aborted);
+            this.finish(turn, { response: { stopReason, usage: promptUsage(messages) } });
+        }
+        catch (error) {
+            if (this.pumpFailure !== undefined)
+                this.notificationFailure();
+            else
+                this.turnError(turn, error);
+        }
+    }
+    async handlePiRejected(turn, error) {
+        if (turn.completed)
+            return;
+        if (!turn.controller.signal.aborted) {
+            this.finish(turn, { error: classifyPreflight(error) });
+            return;
+        }
+        try {
+            const messages = agentMessages(this.pi).slice(turn.startMessageIndex);
+            this.enqueue(usageUpdate(this.pi));
+            await this.drain();
+            this.finish(turn, { response: { stopReason: "cancelled", usage: promptUsage(messages) } });
+        }
+        catch (settlementError) {
+            if (this.pumpFailure !== undefined)
+                this.notificationFailure();
+            else
+                this.turnError(turn, settlementError);
+        }
+    }
+    async prompt(params, requestSignal) {
+        if (this.busy)
+            throw adapterError("session_busy");
+        const converted = convertPromptContent(params.prompt);
+        const schema = params._meta?.outputSchema;
+        let text = converted.text;
+        let structured = false;
+        if (schema !== undefined) {
+            let instruction;
+            try {
+                instruction = this.structured.arm(this.pi, schema);
+            }
+            catch (error) {
+                if (isRequestError(error))
+                    throw error;
+                throw unexpectedError(error);
+            }
+            text = text ? `${instruction}\n\n${text}` : instruction;
+            structured = true;
+        }
+        let startMessageIndex;
+        try {
+            startMessageIndex = agentMessages(this.pi).length;
+        }
+        catch (error) {
+            if (structured) {
+                try {
+                    this.structured.disarm(this.pi);
+                }
+                catch (disarmError) {
+                    console.error("pi-acp structured-output disarm error:", disarmError);
+                }
+            }
+            throw unexpectedError(error);
+        }
+        let resolve;
+        let reject;
+        const result = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        let resolveSettlement;
+        const settlement = new Promise((res) => {
+            resolveSettlement = res;
+        });
+        const turn = {
+            controller: new AbortController(),
+            settledController: new AbortController(),
+            settlement,
+            resolveSettlement,
+            completed: false,
+            notificationFailed: false,
+            backstopStarted: false,
+            resolve,
+            reject,
+            startMessageIndex,
+            structured,
+        };
+        this.activeTurn = turn;
+        turn.controller.signal.addEventListener("abort", () => {
+            try {
+                this.pi.agent.abort();
+            }
+            catch (error) {
+                console.error("pi-acp abort error:", error);
+            }
+            finally {
+                this.startBackstop(turn);
+            }
+        }, { once: true });
+        const abortFromRequest = () => this.abortTurn(turn);
+        if (requestSignal.aborted)
+            abortFromRequest();
+        else {
+            requestSignal.addEventListener("abort", abortFromRequest, { once: true });
+            turn.removeRequestAbort = () => requestSignal.removeEventListener("abort", abortFromRequest);
+        }
+        let piPromise;
+        try {
+            piPromise = this.pi.prompt(text, { images: converted.images });
+        }
+        catch (error) {
+            this.runTurnTask(turn, this.handlePiRejected(turn, error));
+            return result;
+        }
+        void piPromise.then(() => this.runTurnTask(turn, this.handlePiResolved(turn)), (error) => this.runTurnTask(turn, this.handlePiRejected(turn, error)));
+        return result;
+    }
+    cancel() {
+        if (this.activeTurn)
+            this.abortTurn(this.activeTurn);
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.closing = true;
+        const turn = this.activeTurn;
+        if (turn) {
+            this.abortTurn(turn);
+            await turn.settlement;
+        }
+        await this.disposeResources();
+    }
+    async disposeResources() {
+        if (this.disposed)
+            return;
+        this.closing = true;
+        this.disposed = true;
+        this.stopped = true;
+        this.pending.length = 0;
+        this.failedMcpResults.clear();
+        try {
+            this.unsubscribe?.();
+        }
+        catch (error) {
+            console.error("pi-acp unsubscribe error:", error);
+        }
+        this.unsubscribe = undefined;
+        try {
+            await this.pi.dispose();
+        }
+        catch (error) {
+            console.error("pi-acp session dispose error:", error);
+        }
+        try {
+            await disposeMcpBridge(this.mcpClients, this.deps);
+        }
+        catch (error) {
+            console.error("pi-acp MCP disposal error:", error);
+        }
+    }
+}

package/dist/stop-reason.d.ts

@@ -0,0 +1,4 @@
+import type { PromptResponse } from "@agentclientprotocol/sdk";
+import type { AssistantLike } from "./usage.js";
+export declare function stopReasonFor(terminal: AssistantLike | undefined, aborted: boolean): PromptResponse["stopReason"];
+//# sourceMappingURL=stop-reason.d.ts.map

package/dist/stop-reason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-reason.d.ts","sourceRoot":"","sources":["../src/stop-reason.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,aAAa,GAAG,SAAS,EACnC,OAAO,EAAE,OAAO,GACf,cAAc,CAAC,YAAY,CAAC,CAe9B"}

package/dist/stop-reason.js

@@ -0,0 +1,18 @@
+import { classifyTerminal, unexpectedError } from "./errors.js";
+export function stopReasonFor(terminal, aborted) {
+    if (aborted || terminal?.stopReason === "aborted")
+        return "cancelled";
+    switch (terminal?.stopReason) {
+        case "stop":
+        case "toolUse":
+            return "end_turn";
+        case "length":
+            return "max_tokens";
+        case "error":
+            throw classifyTerminal(terminal);
+        case undefined:
+            return "end_turn";
+        default:
+            throw unexpectedError(new Error("Unknown pi stop reason"), terminal);
+    }
+}

package/dist/structured-output.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSession, ToolDefinition } from "@earendil-works/pi-coding-agent";
+export declare const STRUCTURED_TOOL_NAME = "__acp_structured_output";
+export declare class StructuredOutputState {
+    readonly tool: ToolDefinition;
+    private readonly schemaHolder;
+    private captured;
+    private baseActive;
+    constructor();
+    install(session: AgentSession): void;
+    arm(session: AgentSession, schema: unknown): string;
+    disarm(session: AgentSession): void;
+    takeJson(): string | undefined;
+}
+//# sourceMappingURL=structured-output.d.ts.map

package/dist/structured-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-output.d.ts","sourceRoot":"","sources":["../src/structured-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAIpF,eAAO,MAAM,oBAAoB,4BAA4B,CAAC;AAE9D,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,UAAU,CAAgB;;IAoBlC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAQpC,GAAG,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM;IAsBnD,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAKnC,QAAQ,IAAI,MAAM,GAAG,SAAS;CAQ/B"}