@love-moon/ai-sdk 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @love-moon/ai-sdk
 
+## 0.10.0
+
+### Minor Changes
+
+- 43c4f87: Add the `codex-app-server-session` provider, recover Codex oversized threads by
+  rolling onto a fresh provider thread with bounded recent history (one retry per
+  turn), and trim the dsh quota raw payload.
+
 ## 0.9.0
 
 ### Minor Changes

package/dist/manager/quota/dsh.js

@@ -110,6 +110,10 @@ export async function getDshQuota(options = {}) {
         }
         const payload = (await res.json());
         const { isAvailable, balances } = parseDshBalance(payload);
+        // No `raw` field: unlike the window-based providers whose parsing is
+        // lossy, `balances`/`isAvailable` already capture the whole balance
+        // response, so keeping the raw payload would only bloat the cache and the
+        // worker/WebSocket hop to the web client.
         const quota = {
             tool: "dsh",
             isAvailable,
@@ -117,7 +121,6 @@ export async function getDshQuota(options = {}) {
             balances,
             fetchedAt: Math.floor(Date.now() / 1000),
             source: "fresh",
-            raw: payload,
         };
         const entry = await writeCache(file, quota);
         return { ...quota, fetchedAt: entry.fetchedAt };

package/dist/manager/types.d.ts

@@ -128,7 +128,6 @@ export interface DshQuota {
     balances: DshBalanceInfo[];
     fetchedAt: number;
     source: QuotaSource;
-    raw?: Record<string, unknown>;
     error?: string;
 }
 export interface ExternalQuota {

package/dist/providers/codex-app-server-session.d.ts

@@ -53,6 +53,7 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     } | null;
     bootPromise: Promise<void> | null;
     booted: boolean;
+    _contextRecoveryInFlight: boolean;
     goalMode: boolean;
     currentGoal: (import("../shared.js").GoalState & {
         raw?: unknown;
@@ -127,6 +128,22 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     }): void;
     applySessionConfigured(params: any): void;
     resolveContextUsagePercent(): number | undefined;
+    /**
+     * Whether a turn failure was caused by the provider thread outgrowing the
+     * model context window. Such failures are recoverable by rolling onto a fresh
+     * thread; ordinary failures (timeouts, closes, tool errors) are not.
+     *
+     * @param {any} error
+     * @returns {boolean}
+     */
+    isRecoverableContextOverflow(error: any): boolean;
+    /**
+     * Reset thread-bound state so the next {@link boot} starts a brand-new Codex
+     * thread, seeded with the most-recent {@link RECOVERY_HISTORY_LIMIT} history
+     * entries as a prompt preface. The oversized thread is abandoned (never
+     * resumed) so its context can no longer overflow.
+     */
+    rollOntoFreshThread(): void;
     normalizeWorkingStatusPayload(payload: any): {
         source: string;
         reply_in_progress: boolean;
@@ -226,26 +243,7 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         jsonSchema?: null | undefined;
-    }): Promise<{
-        text: string;
-        usage: null;
-        items: never[];
-        events: never[];
-        provider?: undefined;
-        metadata?: undefined;
-    } | {
-        text: string;
-        usage: any;
-        items: any;
-        events: never[];
-        provider: string;
-        metadata: {
-            source: string;
-            threadId: any;
-            threadPath: string | undefined;
-            nativeSessionId: string | undefined;
-        };
-    }>;
+    }): any;
     /**
      * Normalize a goal payload from a codex `thread/goal/*` notification into
      * the cross-layer {@link GoalState} shape.

package/dist/providers/codex-app-server-session.js

@@ -12,6 +12,15 @@ function isTerminalGoalStatusLocal(status) {
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
 const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+// Oversized-thread recovery: when a Codex turn fails because the provider
+// thread outgrew the model context window (and remote compaction could not
+// recover it), roll the same logical chat onto a fresh thread seeded with this
+// many most-recent history entries and retry the prompt once.
+const RECOVERY_HISTORY_LIMIT = 12;
+// Matches the various ways Codex / the underlying model report a context-window
+// overflow. Kept broad but anchored on "context"/"token" wording so ordinary
+// failures are not misclassified as recoverable.
+const CONTEXT_OVERFLOW_PATTERN = /context[ _-]?(?:length|window|limit)|context[ _-]?length[ _-]?exceeded|maximum[ _-]?context|exceed(?:s|ed)?[^.]{0,40}context|too many tokens|token[ _-]?limit|input[^.]{0,20}too long|prompt[^.]{0,20}too long/i;
 function waitForever() {
     return new Promise(() => { });
 }
@@ -217,6 +226,7 @@ export class CodexAppServerSession extends EventEmitter {
         this.currentTurn = null;
         this.bootPromise = null;
         this.booted = false;
+        this._contextRecoveryInFlight = false;
         this.goalMode = options.goalMode === true;
         this.currentGoal = null;
         // Goal-mode lifecycle is decoupled from `currentTurn` so that goal events
@@ -465,6 +475,61 @@ export class CodexAppServerSession extends EventEmitter {
         }
         return Math.max(0, Math.min(100, Math.round((totalTokens / contextWindow) * 100)));
     }
+    /**
+     * Whether a turn failure was caused by the provider thread outgrowing the
+     * model context window. Such failures are recoverable by rolling onto a fresh
+     * thread; ordinary failures (timeouts, closes, tool errors) are not.
+     *
+     * @param {any} error
+     * @returns {boolean}
+     */
+    isRecoverableContextOverflow(error) {
+        if (!error || error.reason === "session_closed" || error.reason === "turn_timeout") {
+            return false;
+        }
+        const parts = [];
+        if (typeof error.message === "string")
+            parts.push(error.message);
+        if (typeof error.turnStatus === "string")
+            parts.push(error.turnStatus);
+        const turnError = error.turnError;
+        if (typeof turnError === "string") {
+            parts.push(turnError);
+        }
+        else if (turnError && typeof turnError === "object") {
+            for (const key of ["message", "code", "type", "reason"]) {
+                if (typeof turnError[key] === "string")
+                    parts.push(turnError[key]);
+            }
+            try {
+                parts.push(JSON.stringify(turnError));
+            }
+            catch {
+                // Ignore non-serializable provider payloads.
+            }
+        }
+        return CONTEXT_OVERFLOW_PATTERN.test(parts.join(" | "));
+    }
+    /**
+     * Reset thread-bound state so the next {@link boot} starts a brand-new Codex
+     * thread, seeded with the most-recent {@link RECOVERY_HISTORY_LIMIT} history
+     * entries as a prompt preface. The oversized thread is abandoned (never
+     * resumed) so its context can no longer overflow.
+     */
+    rollOntoFreshThread() {
+        const recent = this.history.slice(-RECOVERY_HISTORY_LIMIT);
+        this.history = recent;
+        this.pendingHistorySeed = recent.length > 0;
+        this.sessionId = "";
+        this.threadPath = "";
+        this.nativeSessionId = "";
+        this.resumeSessionId = "";
+        this.manualResumeReady = false;
+        this.sessionInfo = null;
+        this.tokenUsage = null;
+        this.booted = false;
+        this.bootPromise = null;
+    }
     normalizeWorkingStatusPayload(payload) {
         return {
             source: CODEX_APP_SERVER_VARIANT,
@@ -1125,6 +1190,51 @@ export class CodexAppServerSession extends EventEmitter {
             if (error?.reason === "turn_timeout") {
                 await this.interruptCurrentTurn();
             }
+            // Oversized-thread recovery: the provider thread outgrew the context
+            // window and remote compaction could not save it. Roll the same logical
+            // chat onto a fresh thread seeded with bounded recent history and retry
+            // the prompt exactly once, rather than surfacing a dead turn. The
+            // in-flight guard ensures a single retry: if the fresh thread also
+            // overflows, the recursive call skips recovery and fails normally.
+            if (!this._contextRecoveryInFlight &&
+                !this.closeRequested &&
+                !currentTurn.goalMode &&
+                this.isRecoverableContextOverflow(error)) {
+                // Drop the user message pushed for the failed attempt; the retry
+                // re-adds it (and folds prior history in as a preface via buildPrompt).
+                if (this.history.length > 0 &&
+                    String(this.history[this.history.length - 1]?.role || "").toLowerCase() === "user") {
+                    this.history.pop();
+                }
+                if (this.currentTurn === currentTurn) {
+                    this.currentTurn = null;
+                }
+                this._contextRecoveryInFlight = true;
+                // Release the outer turn's guards before recursing so their timers do
+                // not linger for the duration of the retry. Both cleanups are
+                // idempotent; the outer `finally` calls them again harmlessly.
+                closeGuard.cleanup();
+                turnTimeoutGuard.cleanup();
+                try {
+                    this.rollOntoFreshThread();
+                    this.trace("context overflow; rolling onto a fresh thread and retrying the turn");
+                    await this.emitWorkingStatus({
+                        phase: "working",
+                        reply_in_progress: true,
+                        status_line: "codex context full; retrying on a fresh thread",
+                    });
+                    this.emit("thread_recovered", { reason: "context_overflow", backend: this.backend });
+                    return await this.runTurn(promptText, {
+                        useInitialImages,
+                        media: mediaInput,
+                        contextFiles,
+                        jsonSchema,
+                    });
+                }
+                finally {
+                    this._contextRecoveryInFlight = false;
+                }
+            }
             if (!this.closeRequested && error?.reason !== "session_closed") {
                 await this.emitWorkingStatus({
                     phase: "turn_failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.9.0"
+    "@love-moon/chat-web": "^0.10.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "606e5a6"
+  "gitCommitId": "bc7b3a5"
 }