@saccolabs/pi-claude-cli 0.4.4 → 0.4.6

package/index.ts

@@ -22,6 +22,44 @@ process.on("exit", killAllProcesses);
 
 const PROVIDER_ID = "pi-claude-cli";
 
+/**
+ * Status key carrying account rate-limit state to the front-end. Neutral
+ * (not pidex-specific) because any pi front-end can read it.
+ */
+const RATE_LIMIT_STATUS_KEY = "claude-rate-limit";
+
+/**
+ * The stream runs deep inside streamSimple, which has no ExtensionContext,
+ * so the ctx handed to session_start is kept for its `ui.setStatus`.
+ */
+let uiContext:
+  { ui?: { setStatus?(key: string, text?: string): void } } | undefined;
+/** Last payload pushed — the CLI repeats this event on every turn. */
+let lastRateLimitJson: string | undefined;
+
+function publishRateLimit(info: Record<string, unknown>): void {
+  const setStatus = uiContext?.ui?.setStatus;
+  if (typeof setStatus !== "function") return;
+  const payload = JSON.stringify({
+    status: info.status,
+    resetsAt: info.resetsAt,
+    rateLimitType: info.rateLimitType,
+    overageStatus: info.overageStatus,
+    isUsingOverage: info.isUsingOverage === true,
+    observedAt: Math.floor(Date.now() / 1000),
+  });
+  // Push only on change: the event repeats every turn, and a status that
+  // rewrites itself constantly is noise for whatever renders it.
+  const withoutObservedAt = payload.replace(/,"observedAt":\d+/, "");
+  if (withoutObservedAt === lastRateLimitJson) return;
+  lastRateLimitJson = withoutObservedAt;
+  try {
+    setStatus.call(uiContext!.ui, RATE_LIMIT_STATUS_KEY, payload);
+  } catch {
+    /* never break a turn over a status push */
+  }
+}
+
 let mcpConfigPath: string | undefined;
 let mcpConfigResolved = false;
 
@@ -91,7 +129,9 @@ export default function (pi: ExtensionAPI) {
 
     // Ensure all registered tools are active so pi can execute them.
     // Some tools (find, grep, ls) are registered but not activated by default.
-    pi.on("session_start", async () => {
+    pi.on("session_start", async (_event: unknown, ctx: unknown) => {
+      uiContext = ctx as typeof uiContext;
+      lastRateLimitJson = undefined;
       const allTools = pi.getAllTools();
       if (Array.isArray(allTools)) {
         pi.setActiveTools(allTools.map((t: any) => t.name));
@@ -107,6 +147,7 @@ export default function (pi: ExtensionAPI) {
       return streamViaCli(model, context, {
         ...options,
         mcpConfigPath: configPath,
+        onRateLimit: publishRateLimit,
       });
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saccolabs/pi-claude-cli",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Pi coding agent extension that routes LLM calls through the Claude Code CLI",
   "main": "index.ts",
   "keywords": [

package/src/prompt-builder.ts

@@ -140,15 +140,22 @@ function buildCustomToolResultPrompt(messages: any[]): string | null {
 /**
  * Build a prompt for a resumed session.
  *
- * When resuming via --resume, the CLI already has the full conversation history.
- * We only need to send the new content since the last turn: the last assistant
- * response's tool results (if any) followed by the latest user message.
+ * When resuming via --resume, the CLI already has the full conversation history
+ * up through the most recent assistant turn it produced. We only need to send
+ * the delta since that turn: trailing tool results for the last assistant
+ * tool_use, and/or a new user message.
  *
- * For tool_use flows: pi sends [user, assistant(toolCall), toolResult, ...]
- * We need to include tool results so the resumed session sees them, plus the
- * final user message.
+ * Why anchor on the last assistant message rather than the last user message?
+ * Pi's tool loop appends [user, assistant(toolUse), toolResult,
+ * assistant(toolUse), toolResult, ...] — the only `user` entry stays at index 0
+ * across many provider invocations. Anchoring there made every iteration replay
+ * the entire transcript, and when that first user message carried an image the
+ * image branch below returned early with just the image, so tool results never
+ * reached the model at all. The model then re-issued the same tool call
+ * indefinitely while each turn re-billed the whole accumulated context.
  *
- * Falls back to full prompt if the message structure is unexpected.
+ * Returns "" when there's nothing new to send (e.g. only an assistant message
+ * exists in the context — can happen mid-shutdown).
  */
 export function buildResumePrompt(context: {
   messages: any[];
@@ -156,28 +163,16 @@ export function buildResumePrompt(context: {
   const messages = context.messages;
   if (messages.length === 0) return "";
 
-  // Find the last user message
-  const finalUserIndex = findFinalUserMessageIndex(messages);
-  if (finalUserIndex < 0) return "";
-
-  // Collect new messages: everything from the last assistant turn onwards
-  // (tool results from the last assistant + the new user message)
-  const newMessages: any[] = [];
-
-  // Walk backwards from finalUserIndex to find where new content starts.
-  // Include trailing toolResult messages that follow the last assistant turn.
-  let startIdx = finalUserIndex;
-  for (let i = finalUserIndex - 1; i >= 0; i--) {
-    if (messages[i].role === "toolResult") {
-      startIdx = i;
-    } else {
+  let lastAssistantIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      lastAssistantIdx = i;
       break;
     }
   }
 
-  for (let i = startIdx; i < messages.length; i++) {
-    newMessages.push(messages[i]);
-  }
+  const newMessages = messages.slice(lastAssistantIdx + 1);
+  if (newMessages.length === 0) return "";
 
   // If there are only tool results + one user message, build a combined prompt
   const parts: string[] = [];

package/src/provider.ts

@@ -55,6 +55,8 @@ const INACTIVITY_TIMEOUT_MS =
 type StreamViaCLiOptions = SimpleStreamOptions & {
   cwd?: string;
   mcpConfigPath?: string;
+  /** Called with account rate-limit state as the CLI reports it. */
+  onRateLimit?: (info: Record<string, unknown>) => void;
 };
 
 /**
@@ -296,6 +298,18 @@ export function streamViaCli(
             rl.close();
             return; // Don't process further -- done event already pushed by event bridge
           }
+        } else if (msg.type === "rate_limit_event") {
+          // Account-level state, not turn content: hand it to the host so a
+          // front-end can surface the window and its reset. Never touches
+          // the assistant message.
+          const info = (msg as any).rate_limit_info;
+          if (info && typeof info === "object") {
+            try {
+              options?.onRateLimit?.(info);
+            } catch {
+              /* a status push must never break a turn */
+            }
+          }
         } else if (msg.type === "assistant") {
           // Complete-block envelopes: marker text for CLI-side tools that
           // would otherwise be invisible between cycles.

package/src/types.ts

@@ -43,6 +43,24 @@ export interface ClaudeAssistantEnvelope {
   };
 }
 
+/**
+ * Emitted when the API reports rate-limit state for the account. Carries the
+ * window and its reset, not a utilization percentage — the percentages the
+ * Claude Code TUI shows come from `anthropic-ratelimit-unified-*` response
+ * headers, which the CLI consumes in-process and does not forward here.
+ */
+export interface ClaudeRateLimitEvent {
+  type: "rate_limit_event";
+  rate_limit_info?: {
+    status?: string;
+    resetsAt?: number;
+    rateLimitType?: string;
+    overageStatus?: string;
+    overageDisabledReason?: string;
+    isUsingOverage?: boolean;
+  };
+}
+
 /** Tool results the CLI feeds back between cycles (top-level only). */
 export interface ClaudeUserEnvelope {
   type: "user";
@@ -81,7 +99,8 @@ export type NdjsonMessage =
   | ClaudeSystemMessage
   | ClaudeControlRequest
   | ClaudeAssistantEnvelope
-  | ClaudeUserEnvelope;
+  | ClaudeUserEnvelope
+  | ClaudeRateLimitEvent;
 
 // Claude API event types (inside stream_event wrapper)