pi-acp 0.0.32 → 0.0.34

package/README.md

@@ -25,6 +25,10 @@ Expect some minor breaking changes.
   - Loads file-based slash commands compatible with pi’s conventions
   - Adds a small set of built-in commands for headless/editor usage
   - Supports skill commands (if enabled in pi settings, they appear as `/skill:skill-name` in the ACP client)
+- Context window usage
+  - Reports pi's real context occupancy (`get_session_stats` → `contextUsage`) to the client as ACP `usage_update` after each turn, on `session/new` and `session/load`, and after a model switch
+  - Requires a pi version whose `get_session_stats` response includes `contextUsage`; otherwise no usage is reported
+  - Right after compaction pi may not have a trustworthy token count yet, so the client keeps the previous value until the next model response
 - Skills are loaded by pi directly and are available in ACP sessions
 - (Zed) `pi-acp` emits “startup info” block into the session (pi version, context, skills, prompts, extensions - similar to `pi` in the terminal). You can disable it by setting `quietStartup: true` in pi settings (`~/.pi/agent/settings.json` or `<project>/.pi/settings.json`). When `quietStartup` is enabled, `pi-acp` will still emit a 'New version available' message if the installed pi version is outdated.
 - (Zed) Session history is supported in Zed starting with [`v0.225.0`](https://zed.dev/releases/preview/0.225.0). Session loading / history maps to pi's session files. Sessions can be resumed both in `pi` and in the ACP client.
@@ -38,7 +42,7 @@ npm install -g @earendil-works/pi-coding-agent
 ```
 
 - Node.js 22+
-- `pi` installed and available on your `PATH` (the adapter runs the `pi` executable)
+- `pi` v0.81.0+ installed and available on your `PATH` (the adapter runs the `pi` executable)
 - Configure `pi` separately for your model providers/API keys
 
 ## Install
@@ -155,7 +159,7 @@ Loaded from:
 
 Other built-in commands:
 
-- `/model` - maps to model selector in Zed
+- `/model` - not implemented (use the model selector UI in Zed)
 - `/thinking` - maps to 'mode' selector in Zed
 - `/clear` - not implemented (use ACP client 'new' command)
 

package/dist/index.js

@@ -54,6 +54,7 @@ import { isAbsolute, resolve as resolvePath } from "path";
 // src/pi-rpc/process.ts
 import { spawn } from "child_process";
 import * as readline from "readline";
+import crossSpawn from "cross-spawn";
 
 // src/pi-rpc/command.ts
 import { platform } from "os";
@@ -89,6 +90,7 @@ var ANSI_ESCAPE_REGEX = new RegExp(
 function stripAnsi(s) {
   return s.replace(ANSI_ESCAPE_REGEX, "");
 }
+var SESSION_STATS_TIMEOUT_MS = 1e3;
 var PiRpcProcess = class _PiRpcProcess {
   child;
   pending = /* @__PURE__ */ new Map();
@@ -109,14 +111,8 @@ var PiRpcProcess = class _PiRpcProcess {
       }
       if (msg?.type === "response") {
         const id = typeof msg.id === "string" ? msg.id : void 0;
-        if (id) {
-          const pending = this.pending.get(id);
-          if (pending) {
-            this.pending.delete(id);
-            pending.resolve(msg);
-            return;
-          }
-        }
+        if (id !== void 0) this.pending.get(id)?.resolve(msg);
+        return;
       }
       for (const h of this.eventHandlers) h(msg);
     });
@@ -134,11 +130,11 @@ var PiRpcProcess = class _PiRpcProcess {
     const cmd = getPiCommand(params.piCommand);
     const args = ["--mode", "rpc", "--no-themes"];
     if (params.sessionPath) args.push("--session", params.sessionPath);
-    const child = spawn(cmd, args, {
+    const start = shouldUseShellForPiCommand(cmd) ? crossSpawn : spawn;
+    const child = start(cmd, args, {
       cwd: params.cwd,
       stdio: "pipe",
-      env: process.env,
-      shell: shouldUseShellForPiCommand(cmd)
+      env: process.env
     });
     try {
       await new Promise((resolve4, reject) => {
@@ -229,6 +225,17 @@ var PiRpcProcess = class _PiRpcProcess {
     if (!res.success) throw new Error(`pi set_model failed: ${res.error ?? JSON.stringify(res.data)}`);
     return res.data;
   }
+  async getAvailableThinkingLevels() {
+    const res = await this.request({ type: "get_available_thinking_levels" });
+    if (!res.success)
+      throw new Error(`pi get_available_thinking_levels failed: ${res.error ?? JSON.stringify(res.data)}`);
+    const data = res.data;
+    const levels = data && typeof data === "object" && "levels" in data ? data.levels : void 0;
+    if (!Array.isArray(levels) || levels.length === 0 || !levels.every((level) => typeof level === "string" && level.length > 0)) {
+      throw new Error("pi get_available_thinking_levels returned invalid levels");
+    }
+    return levels;
+  }
   async setThinkingLevel(level) {
     const res = await this.request({ type: "set_thinking_level", level });
     if (!res.success) throw new Error(`pi set_thinking_level failed: ${res.error ?? JSON.stringify(res.data)}`);
@@ -250,10 +257,10 @@ var PiRpcProcess = class _PiRpcProcess {
     const res = await this.request({ type: "set_auto_compaction", enabled });
     if (!res.success) throw new Error(`pi set_auto_compaction failed: ${res.error ?? JSON.stringify(res.data)}`);
   }
-  async getSessionStats() {
-    const res = await this.request({ type: "get_session_stats" });
+  async getSessionStats(timeoutMs) {
+    const res = await this.request({ type: "get_session_stats" }, { timeoutMs });
     if (!res.success) throw new Error(`pi get_session_stats failed: ${res.error ?? JSON.stringify(res.data)}`);
-    return res.data;
+    return res.data ?? {};
   }
   async setSessionName(name) {
     const res = await this.request({ type: "set_session_name", name });
@@ -283,15 +290,41 @@ var PiRpcProcess = class _PiRpcProcess {
     await this.writeLine(`${JSON.stringify({ type: "extension_ui_response", ...response })}
 `);
   }
-  request(cmd) {
+  request(cmd, opts) {
     const id = crypto.randomUUID();
     const withId = { ...cmd, id };
+    const timeoutMs = opts?.timeoutMs;
     const line = `${JSON.stringify(withId)}
 `;
     return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+      let timer;
+      const drop = () => {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        return this.pending.delete(id);
+      };
+      this.pending.set(id, {
+        resolve: (res) => {
+          drop();
+          resolve4(res);
+        },
+        reject: (error) => {
+          drop();
+          reject(error);
+        }
+      });
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          timer = void 0;
+          if (!this.pending.delete(id)) return;
+          reject(new Error(`pi ${cmd.type} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+      }
       void this.writeLine(line).catch((error) => {
-        this.pending.delete(id);
+        if (!drop()) return;
         reject(error);
       });
     });
@@ -610,6 +643,13 @@ var CONFIRM_PERMISSION_OPTIONS = [
 ];
 var EXTENSION_UI_RAW_INPUT_KEYS = ["title", "message", "options", "placeholder", "prefill"];
 var CHOICE_OPTION_PREFIX = "choice-";
+function toUsageUpdate(stats) {
+  const used = stats?.contextUsage?.tokens;
+  const size = stats?.contextUsage?.contextWindow;
+  if (typeof used !== "number" || !Number.isSafeInteger(used) || used < 0) return null;
+  if (typeof size !== "number" || !Number.isSafeInteger(size) || size <= 0) return null;
+  return { sessionUpdate: "usage_update", used, size };
+}
 function findUniqueLineNumber(text, needle) {
   if (!needle) return void 0;
   const first = text.indexOf(needle);
@@ -787,8 +827,9 @@ var PiAcpSession = class {
   // Some pi events can arrive out of order (e.g. late toolcall_* deltas after execution starts),
   // and clients may hide progress if we ever downgrade back to `pending`.
   currentToolCalls = /* @__PURE__ */ new Map();
-  // pi can emit multiple `turn_end` events for a single user prompt (e.g. after tool_use).
-  // The overall agent loop completes when `agent_end` is emitted.
+  // pi can emit multiple `turn_end` and `agent_end` events for a single user prompt
+  // when retry, compaction, or queued continuations run. The session-level prompt
+  // completes only when `agent_settled` is emitted.
   inAgentLoop = false;
   // For ACP diff support: capture file contents before edit/write mutations,
   // then emit ToolCallContent {type:"diff"}. Compatible structured edit/write
@@ -880,6 +921,41 @@ var PiAcpSession = class {
   async flushEmits() {
     await this.lastEmit;
   }
+  /**
+   * Best-effort: publish the real pi context-window occupancy as ACP `usage_update`.
+   * Queued updates are flushed even when the stats query fails or times out, so callers
+   * can await this before resolving `session/prompt`.
+   */
+  async publishContextUsage() {
+    try {
+      if (typeof this.proc.getSessionStats === "function") {
+        const update = toUsageUpdate(await this.proc.getSessionStats(SESSION_STATS_TIMEOUT_MS));
+        if (update) this.emit(update);
+      }
+    } catch {
+    }
+    await this.flushEmits();
+  }
+  async settleTurn() {
+    await this.publishContextUsage();
+    const reason = this.cancelRequested ? "cancelled" : "end_turn";
+    this.pendingTurn?.resolve(reason);
+    this.pendingTurn = null;
+    this.inAgentLoop = false;
+    const next = this.turnQueue.shift();
+    if (next) {
+      this.emit({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: `Starting queued message. (${this.turnQueue.length} remaining)` }
+      });
+      this.startTurn(next);
+    } else {
+      this.emit({
+        sessionUpdate: "session_info_update",
+        _meta: { piAcp: { queueDepth: 0, running: false } }
+      });
+    }
+  }
   emitBashToolCall(params) {
     this.bashToolCallIds.add(params.toolCallId);
     this.emit({
@@ -1205,25 +1281,11 @@ var PiAcpSession = class {
         break;
       }
       case "agent_end": {
-        void this.flushEmits().finally(() => {
-          const reason = this.cancelRequested ? "cancelled" : "end_turn";
-          this.pendingTurn?.resolve(reason);
-          this.pendingTurn = null;
-          this.inAgentLoop = false;
-          const next = this.turnQueue.shift();
-          if (next) {
-            this.emit({
-              sessionUpdate: "agent_message_chunk",
-              content: { type: "text", text: `Starting queued message. (${this.turnQueue.length} remaining)` }
-            });
-            this.startTurn(next);
-          } else {
-            this.emit({
-              sessionUpdate: "session_info_update",
-              _meta: { piAcp: { queueDepth: 0, running: false } }
-            });
-          }
-        });
+        this.inAgentLoop = false;
+        break;
+      }
+      case "agent_settled": {
+        void this.settleTurn();
         break;
       }
       default:
@@ -1999,10 +2061,15 @@ var PiAcpAgent = class {
         "Configure an API key or log in with an OAuth provider."
       );
     }
-    const { configOptions, models, modes } = await getSessionConfiguration(session.proc, {
-      state,
-      availableModels
-    });
+    let configuration;
+    try {
+      if (stateErr) throw stateErr;
+      configuration = await getSessionConfiguration(session.proc, { state, availableModels });
+    } catch (err) {
+      this.cleanupFailedNewSession(session.sessionId, state);
+      throw maybeAuthRequiredError(err) ?? RequestError3.internalError({}, String(err?.message ?? err));
+    }
+    const { configOptions, models, modes } = configuration;
     const quietStartup = getQuietStartup(params.cwd);
     const updateNotice = buildUpdateNotice();
     const preludeText = quietStartup ? updateNotice ? updateNotice + "\n" : "" : buildStartupInfo({
@@ -2027,6 +2094,7 @@ var PiAcpAgent = class {
     if (preludeText) setTimeout(() => session.sendStartupInfoIfPending(), 0);
     setTimeout(() => {
       void (async () => {
+        await session.publishContextUsage();
         try {
           const pi = await session.proc.getCommands();
           const { commands } = toAvailableCommandsFromPiGetCommands(pi, {
@@ -2468,6 +2536,14 @@ ${JSON.stringify(stats, null, 2)}`;
       mcpServers: params.mcpServers
     });
     const proc = session.proc;
+    let configuration;
+    try {
+      configuration = await getSessionConfiguration(proc);
+    } catch (err) {
+      this.sessions.close(session.sessionId);
+      throw err;
+    }
+    const { configOptions, models, modes } = configuration;
     const fileCommands = loadSlashCommands(params.cwd);
     this.sessions.closeAllExcept?.(session.sessionId);
     this.store.upsert({
@@ -2561,7 +2637,6 @@ ${JSON.stringify(stats, null, 2)}`;
         });
       }
     }
-    const { configOptions, models, modes } = await getSessionConfiguration(proc);
     const response = {
       configOptions,
       models,
@@ -2574,6 +2649,7 @@ ${JSON.stringify(stats, null, 2)}`;
     };
     setTimeout(() => {
       void (async () => {
+        await session.publishContextUsage();
         try {
           const pi = await proc.getCommands();
           const { commands } = toAvailableCommandsFromPiGetCommands(pi, {
@@ -2621,66 +2697,48 @@ ${JSON.stringify(stats, null, 2)}`;
     const session = await this.restoreSession(params.sessionId);
     await setSessionModel(session.proc, params.modelId);
     await emitConfigOptionsUpdate(this.conn, session.sessionId, session.proc);
+    await session.publishContextUsage();
   }
   async setSessionMode(params) {
     const session = await this.restoreSession(params.sessionId);
-    const mode = String(params.modeId);
-    if (!isThinkingLevel(mode)) {
-      throw RequestError3.invalidParams(`Unknown modeId: ${mode}`);
+    const mode = params.modeId;
+    if (typeof mode !== "string" || mode.length === 0) {
+      throw RequestError3.invalidParams("Expected nonempty string modeId");
     }
     await session.proc.setThinkingLevel(mode);
-    void this.conn.sessionUpdate({
-      sessionId: session.sessionId,
-      update: {
-        sessionUpdate: "current_mode_update",
-        currentModeId: mode
-      }
-    });
     await emitConfigOptionsUpdate(this.conn, session.sessionId, session.proc);
     return {};
   }
   async setSessionConfigOption(params) {
     const session = await this.restoreSession(params.sessionId);
     const configId = String(params.configId);
+    let modelChanged = false;
     if (typeof params.value !== "string") {
       throw RequestError3.invalidParams(`Expected string value for config option: ${configId}`);
     }
     if (configId === MODEL_CONFIG_ID) {
       await setSessionModel(session.proc, params.value);
+      modelChanged = true;
     } else if (configId === THOUGHT_LEVEL_CONFIG_ID) {
-      if (!isThinkingLevel(params.value)) {
-        throw RequestError3.invalidParams(`Unknown thinking level: ${params.value}`);
+      if (params.value.length === 0) {
+        throw RequestError3.invalidParams("Expected nonempty thinking level");
       }
       await session.proc.setThinkingLevel(params.value);
-      void this.conn.sessionUpdate({
-        sessionId: session.sessionId,
-        update: {
-          sessionUpdate: "current_mode_update",
-          currentModeId: params.value
-        }
-      });
     } else {
       throw RequestError3.invalidParams(`Unknown config option: ${configId}`);
     }
     const configOptions = await emitConfigOptionsUpdate(this.conn, session.sessionId, session.proc);
+    if (modelChanged) await session.publishContextUsage();
     return { configOptions };
   }
 };
-function isThinkingLevel(x) {
-  return x === "off" || x === "minimal" || x === "low" || x === "medium" || x === "high" || x === "xhigh";
-}
 async function getThinkingState(proc, pre) {
-  let current = "medium";
-  const state = pre?.state ?? await (async () => {
-    try {
-      return await proc.getState();
-    } catch {
-      return null;
-    }
-  })();
-  const tl = typeof state?.thinkingLevel === "string" ? state.thinkingLevel : null;
-  if (tl && isThinkingLevel(tl)) current = tl;
-  const available = ["off", "minimal", "low", "medium", "high", "xhigh"];
+  const state = pre?.state ?? await proc.getState();
+  const available = await proc.getAvailableThinkingLevels();
+  const current = state && typeof state === "object" && "thinkingLevel" in state ? state.thinkingLevel : void 0;
+  if (typeof current !== "string" || current.length === 0 || !available.includes(current)) {
+    throw new Error("pi returned a thinking level absent from available levels");
+  }
   return {
     currentModeId: current,
     availableModes: available.map((id) => ({
@@ -2691,7 +2749,8 @@ async function getThinkingState(proc, pre) {
   };
 }
 async function getSessionConfiguration(proc, pre) {
-  const [models, modes] = await Promise.all([getModelState(proc, pre), getThinkingState(proc, { state: pre?.state })]);
+  const state = pre?.state ?? await proc.getState();
+  const [models, modes] = await Promise.all([getModelState(proc, { ...pre, state }), getThinkingState(proc, { state })]);
   return {
     configOptions: buildConfigOptions({ models, modes }),
     models,
@@ -2774,7 +2833,11 @@ async function getModelState(proc, pre) {
   };
 }
 async function emitConfigOptionsUpdate(conn, sessionId, proc) {
-  const { configOptions } = await getSessionConfiguration(proc);
+  const { configOptions, modes } = await getSessionConfiguration(proc);
+  await conn.sessionUpdate({
+    sessionId,
+    update: { sessionUpdate: "current_mode_update", currentModeId: modes.currentModeId }
+  });
   await conn.sessionUpdate({
     sessionId,
     update: {