replicas-engine 0.1.133 → 0.1.134

package/dist/src/index.js

@@ -967,6 +967,9 @@ import { homedir as homedir5 } from "os";
 import { exec } from "child_process";
 import { promisify as promisify2 } from "util";
 
+// ../shared/src/event.ts
+var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
+
 // ../shared/src/pricing.ts
 var PLANS = {
   hobby: {
@@ -1166,7 +1169,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "29-04-2026-royal-york-v1";
+var DAYTONA_SNAPSHOT_ID = "01-05-2026-royal-york-v1";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -2828,12 +2831,40 @@ function isJsonlEvent2(value) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function extractRateLimitsSnapshot(parsed) {
+  if (!isRecord(parsed)) return null;
+  const payload = isRecord(parsed.payload) ? parsed.payload : parsed;
+  const rateLimits = isRecord(payload.rate_limits) ? payload.rate_limits : null;
+  if (!rateLimits) return null;
+  const credits = isRecord(rateLimits.credits) ? rateLimits.credits : null;
+  const hasCredits = credits && typeof credits.has_credits === "boolean" ? credits.has_credits : null;
+  const unlimited = credits && typeof credits.unlimited === "boolean" ? credits.unlimited : null;
+  const balance = credits && typeof credits.balance === "string" ? credits.balance : null;
+  if (unlimited === true) return null;
+  const rateLimitResetType = typeof rateLimits.rate_limit_reached_type === "string" && rateLimits.rate_limit_reached_type.length > 0 ? rateLimits.rate_limit_reached_type : null;
+  const planType = typeof rateLimits.plan_type === "string" ? rateLimits.plan_type : null;
+  let state = "ok";
+  if (hasCredits === false) {
+    state = "out_of_credits";
+  } else if (rateLimitResetType !== null) {
+    state = "rate_limited";
+  }
+  return { state, balance, rateLimitResetType, planType };
+}
 var CodexManager = class extends CodingAgentManager {
   codex;
   currentThreadId = null;
   currentThread = null;
   tempImageDir;
   activeAbortController = null;
+  /** Most recent quota state observed from a rollout `rate_limits` payload. */
+  latestQuotaState = "ok";
+  /** Last state actually emitted to the UI. Drives dedup so seeded historical state still emits the first time it surfaces in a turn. */
+  lastEmittedQuotaState = "ok";
+  /** Last full snapshot, retained so we can re-emit when a user retries while blocked. */
+  latestQuotaSnapshot = null;
+  /** When true, new turns short-circuit instead of running. Set by `out_of_credits`. */
+  quotaBlocked = false;
   constructor(options) {
     super(options);
     const codexApiKey = resolveCodexApiKey();
@@ -2850,6 +2881,73 @@ var CodexManager = class extends CodingAgentManager {
       console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
     }
   }
+  /**
+   * One-shot pass over the current session's rollout jsonl to find the most
+   * recent `rate_limits` entry and emit a quota state if it has changed.
+   * Used after `runStreamed` throws — the tail loop may not have pumped the
+   * fatal line before the SDK exited.
+   */
+  async flushQuotaSnapshotFromCurrentSession() {
+    if (!this.currentThreadId) return;
+    try {
+      const sessionFile = await this.findSessionFile(this.currentThreadId);
+      if (!sessionFile) return;
+      const content = await readFile7(sessionFile, "utf-8");
+      const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+      let latest = null;
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          const snapshot = extractRateLimitsSnapshot(parsed);
+          if (snapshot) {
+            latest = snapshot;
+          }
+        } catch {
+        }
+      }
+      if (latest) {
+        this.emitQuotaStatus(latest);
+      }
+    } catch (error) {
+      console.warn("[CodexManager] Failed to flush quota snapshot from session:", error);
+    }
+  }
+  /**
+   * Emit a synthetic codex-quota-status AgentEvent and update local state.
+   * Dedupes against `lastEmittedQuotaState` (what the UI has actually seen),
+   * not `latestQuotaState`, so a state primed silently by `seedSeenLines` on
+   * engine restart still emits the first time it surfaces in a turn. Pass
+   * `force` to re-emit on a retry so users see the banner reappear.
+   */
+  emitQuotaStatus(snapshot, force = false) {
+    const stateChanged = snapshot.state !== this.lastEmittedQuotaState;
+    if (!stateChanged && !force) {
+      return;
+    }
+    this.latestQuotaState = snapshot.state;
+    this.lastEmittedQuotaState = snapshot.state;
+    this.quotaBlocked = snapshot.state === "out_of_credits";
+    this.latestQuotaSnapshot = snapshot;
+    const payload = {
+      state: snapshot.state,
+      balance: snapshot.balance,
+      rateLimitResetType: snapshot.rateLimitResetType,
+      planType: snapshot.planType
+    };
+    this.onEvent({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: CODEX_QUOTA_STATUS_EVENT_TYPE,
+      payload
+    });
+    if (!stateChanged) return;
+    if (snapshot.state === "out_of_credits") {
+      console.warn("[CodexManager] Codex account out of credits \u2014 pausing turn processing.");
+    } else if (snapshot.state === "rate_limited") {
+      console.warn(`[CodexManager] Codex rate limit reached (${snapshot.rateLimitResetType}).`);
+    } else {
+      console.log("[CodexManager] Codex quota recovered.");
+    }
+  }
   async interruptActiveTurn() {
     if (this.activeAbortController) {
       this.activeAbortController.abort();
@@ -2908,6 +3006,18 @@ var CodexManager = class extends CodingAgentManager {
    * Internal method that actually processes the message
    */
   async processMessageInternal(request) {
+    if (this.quotaBlocked && this.latestQuotaSnapshot) {
+      await this.flushQuotaSnapshotFromCurrentSession();
+      if (this.quotaBlocked && this.latestQuotaSnapshot) {
+        this.emitQuotaStatus(this.latestQuotaSnapshot, true);
+        try {
+          await this.onTurnComplete();
+        } catch (error) {
+          console.error("[CodexManager] onTurnComplete failed during quota-blocked turn:", error);
+        }
+        return;
+      }
+    }
     const {
       message,
       model,
@@ -2944,8 +3054,8 @@ var CodexManager = class extends CodingAgentManager {
         this.currentThread = this.codex.resumeThread(this.currentThreadId, threadOptions);
       } else {
         this.currentThread = this.codex.startThread(threadOptions);
-        const { events: events2 } = await this.currentThread.runStreamed("Hello", { signal: abortController.signal });
-        for await (const event of events2) {
+        const { events } = await this.currentThread.runStreamed("Hello", { signal: abortController.signal });
+        for await (const event of events) {
           if (event.type === "thread.started") {
             this.currentThreadId = event.thread_id;
             await this.onSaveSessionId(this.currentThreadId);
@@ -2969,38 +3079,47 @@ var CodexManager = class extends CodingAgentManager {
       } else {
         input = message;
       }
-      const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
-      let latestThoughtEvent = null;
-      for await (const event of events) {
-        if (linearSessionId) {
-          const plan = extractPlanFromCodexEvent(event);
-          if (plan) {
-            monolithService.sendEvent({
-              type: "agent_plan_update",
-              payload: { linearSessionId, plan }
-            }).catch(() => {
-            });
-          }
-          const linearEvent = convertCodexEvent(event, linearSessionId);
-          if (linearEvent) {
-            if (latestThoughtEvent) {
-              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+      try {
+        const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
+        let latestThoughtEvent = null;
+        for await (const event of events) {
+          if (linearSessionId) {
+            const plan = extractPlanFromCodexEvent(event);
+            if (plan) {
+              monolithService.sendEvent({
+                type: "agent_plan_update",
+                payload: { linearSessionId, plan }
+              }).catch(() => {
               });
             }
-            if (isLinearThoughtEvent2(linearEvent)) {
-              latestThoughtEvent = linearEvent;
-            } else {
-              latestThoughtEvent = null;
-              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-              });
+            const linearEvent = convertCodexEvent(event, linearSessionId);
+            if (linearEvent) {
+              if (latestThoughtEvent) {
+                monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+                });
+              }
+              if (isLinearThoughtEvent2(linearEvent)) {
+                latestThoughtEvent = linearEvent;
+              } else {
+                latestThoughtEvent = null;
+                monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+                });
+              }
             }
           }
         }
-      }
-      if (linearSessionId && latestThoughtEvent) {
-        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
-        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
-        });
+        if (linearSessionId && latestThoughtEvent) {
+          const responseEvent = linearThoughtToResponse(latestThoughtEvent);
+          monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
+          });
+        }
+      } catch (error) {
+        await this.flushQuotaSnapshotFromCurrentSession();
+        if (this.quotaBlocked) {
+          console.warn("[CodexManager] runStreamed failed while quota was blocked \u2014 surfacing as quota state.");
+          return;
+        }
+        throw error;
       }
     } finally {
       if (stopTail) {
@@ -3100,8 +3219,20 @@ var CodexManager = class extends CodingAgentManager {
       try {
         const content = await readFile7(sessionFile, "utf-8");
         const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+        let latest = null;
         for (const line of lines) {
           seenLines.add(line);
+          try {
+            const parsed = JSON.parse(line);
+            const snapshot = extractRateLimitsSnapshot(parsed);
+            if (snapshot) latest = snapshot;
+          } catch {
+          }
+        }
+        if (latest) {
+          this.latestQuotaState = latest.state;
+          this.latestQuotaSnapshot = latest;
+          this.quotaBlocked = latest.state === "out_of_credits";
         }
       } catch {
       }
@@ -3121,6 +3252,10 @@ var CodexManager = class extends CodingAgentManager {
           seenLines.add(trimmed);
           try {
             const parsed = JSON.parse(trimmed);
+            const snapshot = extractRateLimitsSnapshot(parsed);
+            if (snapshot) {
+              this.emitQuotaStatus(snapshot);
+            }
             if (isJsonlEvent2(parsed)) {
               this.onEvent(parsed);
               emitted += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.133",
+  "version": "0.1.134",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",