@automatalabs/pi-acp 0.1.3 → 0.2.1

package/dist/session.js

@@ -1,22 +1,24 @@
 import { methods, } from "@agentclientprotocol/sdk";
 import { adapterError, classifyPreflight, isRequestError, unexpectedError } from "./errors.js";
-import { applyConfig, thinkingLevelOption } from "./config.js";
+import { applyConfig, modelOption, 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";
+import { ChildCleanupFailure } from "./child-process-registry.js";
 export class PiSession {
     sessionId;
     pi;
     manager;
     client;
     deps;
-    mcpClients;
+    mcpBridge;
     failedMcpResults;
-    structured;
+    availableModels;
+    childRegistry;
+    lifecycleController;
     onWedged;
     pending = [];
     pump;
@@ -26,15 +28,22 @@ export class PiSession {
     disposed = false;
     unsubscribe;
     activeTurn;
+    configReserved = false;
+    cleanupDirty = false;
+    cleanupGeneration;
+    resourceDisposePromise;
+    bridgeClosePromise;
     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.mcpBridge = options.mcpBridge;
         this.failedMcpResults = options.failedMcpResults;
-        this.structured = options.structured;
+        this.availableModels = options.availableModels;
+        this.childRegistry = options.childRegistry;
+        this.lifecycleController = options.lifecycleController;
         this.onWedged = options.onWedged;
         installPermissionWrapper(this.pi, {
             sessionId: this.sessionId,
@@ -66,10 +75,24 @@ export class PiSession {
         });
     }
     get busy() {
-        return this.activeTurn !== undefined || this.closing;
+        return this.activeTurn !== undefined || this.configReserved || this.closing;
     }
     configOptions() {
-        return [thinkingLevelOption(this.pi)];
+        return [thinkingLevelOption(this.pi), modelOption(this.pi, this.availableModels)];
+    }
+    publishAvailableModels(models) {
+        this.availableModels = [...models];
+    }
+    activeTurnSignal() { return this.activeTurn?.controller.signal; }
+    emitMcpDiagnostic(text) {
+        if (this.disposed)
+            return;
+        if (this.activeTurn && !this.activeTurn.completed && this.activeTurn.diagnosticOpen) {
+            this.enqueue({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text } });
+        }
+        else {
+            console.error(text);
+        }
     }
     enqueue(update) {
         if (this.stopped)
@@ -125,34 +148,44 @@ export class PiSession {
     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;
+        // Reserve synchronously before the corrective catalog refresh.  Prompt,
+        // config, fork, and refresh commit all share the same admission boundary.
+        this.configReserved = true;
+        let release;
         try {
-            this.structured.disarm(this.pi);
+            release = await this.mcpBridge.acquireTurnBoundary();
+            if (this.closing)
+                throw adapterError("session_busy");
+            const result = await applyConfig(this.pi, this.deps.modelRuntime, this.availableModels, configId, value);
+            this.availableModels = result.availableModels;
+            return result.configOptions;
         }
-        catch (error) {
-            console.error("pi-acp structured-output disarm error:", error);
+        finally {
+            release?.();
+            this.configReserved = false;
         }
     }
-    finish(turn, outcome, keepBackstop = false) {
+    finish(turn, outcome) {
         if (turn.completed)
             return;
+        turn.diagnosticOpen = false;
         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();
+        turn.releaseBoundary?.();
+        turn.releaseBoundary = undefined;
+        if (this.activeTurn === turn)
+            this.activeTurn = undefined;
+        const generation = this.cleanupGeneration;
+        if (generation?.resumeRefreshesOnSettlement && generation.mode === "cancel-only") {
+            this.cleanupGeneration = undefined;
+            this.mcpBridge.resumeRefreshes();
+        }
     }
     notificationFailure() {
         const turn = this.activeTurn;
@@ -160,17 +193,135 @@ export class PiSession {
             return;
         turn.notificationFailed = true;
         this.abortTurn(turn);
-        this.finish(turn, { error: adapterError("notification_error") }, true);
+        void turn.cleanup?.then(() => this.finish(turn, { error: adapterError("notification_error") }), (error) => this.finish(turn, { error }));
     }
     abortTurn(turn) {
         if (turn.completed)
             return;
-        if (!turn.controller.signal.aborted)
+        turn.cleanup ??= this.cleanupTurn("cancel-only");
+        turn.cleanup.catch((error) => {
+            if (!turn.completed)
+                this.turnError(turn, error);
+            void this.cleanupWedged();
+        });
+    }
+    startDisposal() {
+        this.closing = true;
+        // The contract's disposal prefix is intentionally split: transport close
+        // admission starts first, then incoming handlers observe session disposal,
+        // and only then are refresh/turn signals aborted.
+        this.mcpBridge.startDisposal();
+        if (!this.lifecycleController.signal.aborted) {
+            this.lifecycleController.abort(new Error("session disposed"));
+        }
+        this.mcpBridge.abortRefreshes();
+        this.bridgeClosePromise ??= this.mcpBridge.close();
+        this.bridgeClosePromise.catch(() => undefined);
+    }
+    cleanupTurn(mode) {
+        const current = this.cleanupGeneration;
+        if (current?.status === "pending") {
+            if (mode === "disposal" && current.mode === "cancel-only") {
+                current.mode = "disposal";
+                this.startDisposal();
+            }
+            return current.promise;
+        }
+        if (current?.status === "succeeded" && current.mode === "disposal") {
+            return current.promise;
+        }
+        const deadlineController = new AbortController();
+        const timerController = new AbortController();
+        const generation = {
+            mode,
+            status: "pending",
+            promise: Promise.resolve(),
+            deadlineController,
+            timerController,
+        };
+        this.cleanupGeneration = generation;
+        const expiry = this.deps.sleep(this.deps.graceMs, timerController.signal).then(() => {
+            const failure = new ChildCleanupFailure(this.childRegistry.remainingChildren);
+            deadlineController.abort(failure);
+            throw failure;
+        });
+        expiry.catch(() => undefined);
+        // Closing the captured epoch is the synchronous admission barrier.  It
+        // must precede Pi abort, because abort can yield while a bash spawn is
+        // between its filesystem check and lease acquisition.
+        const captured = this.childRegistry.closeEpoch(deadlineController.signal);
+        captured.drain.catch(() => undefined);
+        if (mode === "disposal")
+            this.startDisposal();
+        else
+            this.mcpBridge.abortRefreshes();
+        const turn = this.activeTurn;
+        if (turn && !turn.controller.signal.aborted)
             turn.controller.abort();
+        let abortPi;
+        try {
+            abortPi = this.pi.abort();
+        }
+        catch (error) {
+            abortPi = Promise.reject(error);
+        }
+        abortPi.catch(() => undefined);
+        const operations = Promise.allSettled([abortPi, captured.drain]);
+        generation.promise = new Promise((resolve, reject) => {
+            let claimed = false;
+            const fail = (error) => {
+                if (claimed)
+                    return;
+                claimed = true;
+                generation.status = "failed";
+                this.cleanupDirty = true;
+                generation.mode = "disposal";
+                this.startDisposal();
+                const remaining = error instanceof ChildCleanupFailure
+                    ? error.remainingChildren
+                    : this.childRegistry.remainingChildren;
+                generation.error = adapterError("child_cleanup_error", { details: { remainingChildren: remaining } });
+                timerController.abort();
+                reject(generation.error);
+            };
+            expiry.then(() => undefined, (error) => {
+                if (timerController.signal.aborted && !deadlineController.signal.aborted)
+                    return;
+                fail(error);
+            });
+            operations.then((results) => {
+                if (claimed)
+                    return;
+                const failure = results.find((result) => result.status === "rejected");
+                if (failure) {
+                    fail(failure.reason);
+                    return;
+                }
+                claimed = true;
+                generation.status = "succeeded";
+                this.cleanupDirty = false;
+                timerController.abort();
+                if (generation.mode === "cancel-only" && this.cleanupGeneration === generation) {
+                    this.childRegistry.commitRotation(captured.epoch);
+                    if (turn?.completed) {
+                        this.cleanupGeneration = undefined;
+                        this.mcpBridge.resumeRefreshes();
+                    }
+                    else {
+                        generation.resumeRefreshesOnSettlement = true;
+                    }
+                }
+                resolve();
+            });
+        });
+        generation.promise.catch(() => undefined);
+        return generation.promise;
     }
     turnError(turn, error) {
-        if (turn.completed)
+        if (turn.completed || turn.errorSettlementStarted)
             return;
+        turn.errorSettlementStarted = true;
+        turn.diagnosticOpen = false;
         let terminal;
         try {
             terminal = terminalAssistant(agentMessages(this.pi).slice(turn.startMessageIndex));
@@ -178,7 +329,8 @@ export class PiSession {
         catch {
             terminal = undefined;
         }
-        this.finish(turn, { error: isRequestError(error) ? error : unexpectedError(error, terminal) });
+        const mapped = isRequestError(error) ? error : unexpectedError(error, terminal);
+        void this.drain().then(() => this.finish(turn, { error: mapped }), () => this.notificationFailure());
     }
     runTurnTask(turn, task) {
         void task.catch((error) => {
@@ -190,61 +342,22 @@ export class PiSession {
     }
     async cleanupWedged() {
         try {
-            await this.onWedged(this.sessionId, this);
+            await this.onWedged(this.sessionId, this, true);
         }
         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 {
+            if (this.childRegistry.childCleanupFailed)
+                turn.cleanup ??= this.cleanupTurn("disposal");
             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 } });
-                }
-            }
+            if (turn.cleanup)
+                await turn.cleanup;
+            turn.diagnosticOpen = false;
             this.enqueue(usageUpdate(this.pi));
             await this.drain();
             if (turn.completed)
@@ -264,11 +377,21 @@ export class PiSession {
         if (turn.completed)
             return;
         if (!turn.controller.signal.aborted) {
-            this.finish(turn, { error: classifyPreflight(error) });
+            turn.diagnosticOpen = false;
+            try {
+                await this.drain();
+                this.finish(turn, { error: classifyPreflight(error) });
+            }
+            catch {
+                this.notificationFailure();
+            }
             return;
         }
         try {
+            if (turn.cleanup)
+                await turn.cleanup;
             const messages = agentMessages(this.pi).slice(turn.startMessageIndex);
+            turn.diagnosticOpen = false;
             this.enqueue(usageUpdate(this.pi));
             await this.drain();
             this.finish(turn, { response: { stopReason: "cancelled", usage: promptUsage(messages) } });
@@ -284,35 +407,12 @@ export class PiSession {
         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;
-        }
+        const text = converted.text;
         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;
@@ -327,29 +427,17 @@ export class PiSession {
         });
         const turn = {
             controller: new AbortController(),
-            settledController: new AbortController(),
             settlement,
             resolveSettlement,
             completed: false,
+            diagnosticOpen: true,
+            errorSettlementStarted: 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();
@@ -357,58 +445,126 @@ export class PiSession {
             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)));
+        this.runTurnTask(turn, (async () => {
+            turn.releaseBoundary = await this.mcpBridge.acquireTurnBoundary();
+            if (turn.controller.signal.aborted) {
+                try {
+                    if (turn.cleanup)
+                        await turn.cleanup;
+                    turn.diagnosticOpen = false;
+                    this.enqueue(usageUpdate(this.pi));
+                    await this.drain();
+                    this.finish(turn, {
+                        response: {
+                            stopReason: "cancelled",
+                            usage: { inputTokens: 0, outputTokens: 0, cachedReadTokens: 0, cachedWriteTokens: 0, totalTokens: 0 },
+                        },
+                    });
+                }
+                catch (error) {
+                    this.turnError(turn, error);
+                }
+                return;
+            }
+            let piPromise;
+            try {
+                piPromise = this.pi.prompt(text, { images: converted.images });
+            }
+            catch (error) {
+                await this.handlePiRejected(turn, error);
+                return;
+            }
+            await piPromise.then(() => this.handlePiResolved(turn), (error) => this.handlePiRejected(turn, error));
+        })());
         return result;
     }
     cancel() {
         if (this.activeTurn)
             this.abortTurn(this.activeTurn);
     }
+    childCleanupFailure() {
+        const turn = this.activeTurn;
+        if (turn && !turn.completed) {
+            this.abortTurn(turn);
+            return;
+        }
+        void this.cleanupWedged();
+    }
     async dispose() {
-        if (this.disposed)
+        if (this.disposed && !this.cleanupDirty && this.childRegistry.remainingChildren === 0 && !this.childRegistry.childCleanupFailed)
             return;
-        this.closing = true;
+        const cleanup = this.cleanupTurn("disposal");
         const turn = this.activeTurn;
+        let cleanupError;
         if (turn) {
             this.abortTurn(turn);
             await turn.settlement;
+            try {
+                await cleanup;
+            }
+            catch (error) {
+                cleanupError = error;
+            }
         }
+        else {
+            try {
+                await cleanup;
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+        }
+        await this.disposeResources();
+        if (cleanupError)
+            throw cleanupError;
+    }
+    async disposeAfterCleanupFailure() {
+        this.startDisposal();
         await this.disposeResources();
     }
+    get remainingChildren() { return this.childRegistry.remainingChildren; }
+    get cleanupRetryRequired() {
+        return this.cleanupDirty || this.childRegistry.remainingChildren > 0 || this.childRegistry.childCleanupFailed;
+    }
     async disposeResources() {
-        if (this.disposed)
+        this.resourceDisposePromise ??= (async () => {
+            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;
+            this.startDisposal();
+            await this.mcpBridge.drainRefreshes().catch((error) => {
+                console.error("pi-acp MCP refresh drain error:", error);
+            });
+            const results = await Promise.allSettled([
+                Promise.resolve().then(() => this.pi.dispose()),
+                this.bridgeClosePromise ?? Promise.resolve(),
+            ]);
+            if (results[0]?.status === "rejected") {
+                console.error("pi-acp session dispose error:", results[0].reason);
+            }
+            if (results[1]?.status === "rejected") {
+                console.error("pi-acp MCP disposal error:", results[1].reason);
+            }
+        })();
+        return this.resourceDisposePromise;
+    }
+    poison() {
+        if (this.closing || 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);
-        }
+        void this.onWedged(this.sessionId, this, false).catch((error) => {
+            console.error("pi-acp poisoned-session cleanup error:", error);
+        });
     }
 }

package/dist/translate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translate.d.ts","sourceRoot":"","sources":["../src/translate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,UAAU,QAAQ;IAChB,OAAO,CAAC,EAAE,KAAK,CACX;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAC9B;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CACpD,CAAC;IACF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAgBlD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,EAAE,GAAG,SAAS,CAI3E;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,YAAY,EAAE,CAM7D;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,EAAE,CAE7D;AA4BD,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,EAAE,YAAY,CAAC,EAAE,QAAQ,GAAG,aAAa,EAAE,CAsDjG"}
+{"version":3,"file":"translate.d.ts","sourceRoot":"","sources":["../src/translate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,UAAU,QAAQ;IAChB,OAAO,CAAC,EAAE,KAAK,CACX;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAC9B;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CACpD,CAAC;IACF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAgBlD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,EAAE,GAAG,SAAS,CAI3E;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,YAAY,EAAE,CAM7D;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,EAAE,CAE7D;AA4BD,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,EAAE,YAAY,CAAC,EAAE,QAAQ,GAAG,aAAa,EAAE,CAyDjG"}

package/dist/translate.js

@@ -68,12 +68,16 @@ export function translateEvent(event, failedResult) {
                     _meta: { toolName: event.toolName },
                 }];
         case "tool_execution_update":
-            return [{
-                    sessionUpdate: "tool_call_update",
-                    toolCallId: event.toolCallId,
-                    status: "in_progress",
-                    content: toContent(event.partialResult),
-                }];
+            const update = {
+                sessionUpdate: "tool_call_update",
+                toolCallId: event.toolCallId,
+                status: "in_progress",
+                content: toContent(event.partialResult),
+            };
+            const partial = event.partialResult;
+            if (partial.details !== undefined)
+                update.rawOutput = partial.details;
+            return [update];
         case "tool_execution_end": {
             const result = failedResult ?? event.result;
             const update = {

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PKG_VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAEvB,CAAC"}

package/dist/version.js

@@ -0,0 +1,2 @@
+import { readFileSync } from "node:fs";
+export const PKG_VERSION = String(JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automatalabs/pi-acp",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "license": "Apache-2.0",
   "engines": {
     "node": ">=22.19.0"
@@ -31,13 +31,13 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
+    "@earendil-works/pi-ai": "0.80.10",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@modelcontextprotocol/sdk": "1.29.0",
     "typebox": "1.3.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.80.10",
-    "@earendil-works/pi-ai": "0.80.10"
+    "@earendil-works/pi-agent-core": "0.80.10"
   },
   "scripts": {
     "build": "tsc -b",