@resolveio/server-lib 22.0.11 → 22.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.0.11",
+  "version": "22.0.13",
   "description": "",
 	"scripts": {
 		"package": "./build_package.sh",

package/services/codex-client.d.ts

@@ -33,6 +33,12 @@ export type CodexThreadOptions = {
 export declare class CodexClient {
     private static readonly PING_PROMPT;
     private static readonly DEFAULT_FALLBACK_MODEL;
+    private static readonly MODEL_UNAVAILABLE_FALLBACK_FILE;
+    private static readonly DEFAULT_MODEL_UNAVAILABLE_TTL_MS;
+    private static readonly MIN_MODEL_UNAVAILABLE_TTL_MS;
+    private static readonly modelFallbackPreferences;
+    private static modelFallbackPreferencesLoaded;
+    private static modelFallbackPreferencesLoadPromise;
     private codex;
     private codexInit;
     private readonly threadCache;
@@ -43,6 +49,7 @@ export declare class CodexClient {
     private readonly defaultTimeoutMs;
     private readonly pingEnabled;
     private readonly pingTimeoutMs;
+    private readonly modelUnavailableTtlMs;
     private readonly config;
     private readonly defaultThreadOptions;
     constructor(config: CodexConfig);
@@ -65,6 +72,13 @@ export declare class CodexClient {
     private isModelAvailabilityError;
     private isRetryableError;
     private normalizeOptionalString;
+    private resolveModelUnavailableTtlMs;
+    private ensureModelFallbackPreferencesLoaded;
+    private pruneModelFallbackPreferences;
+    private getModelFallbackPreference;
+    private rememberModelFallbackPreference;
+    private clearModelFallbackPreference;
+    private persistModelFallbackPreferences;
     private sleep;
     private ensureCodex;
     private log;

package/services/codex-client.js

@@ -107,6 +107,7 @@ var CodexClient = /** @class */ (function () {
         this.defaultTimeoutMs = this.resolveDefaultTimeoutMs();
         this.pingEnabled = this.resolvePingEnabled();
         this.pingTimeoutMs = this.resolvePingTimeoutMs();
+        this.modelUnavailableTtlMs = this.resolveModelUnavailableTtlMs();
         this.config = config;
         if (!this.config.apiKey) {
             throw new Error('OPENAI_API_KEY is required for CodexClient');
@@ -115,63 +116,78 @@ var CodexClient = /** @class */ (function () {
     }
     CodexClient.prototype.run = function (prompt, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var maxRetries, retryDelayMs, lastError, modelSequence, modelIndex, model, nextModel, modelOptions, attempt, error_1, message, delay;
+            var maxRetries, retryDelayMs, lastError, modelSequence, modelIndex, model, nextModel, modelOptions, attempt, result_1, result, error_1, message, delay;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
+                    case 0: return [4 /*yield*/, this.ensureModelFallbackPreferencesLoaded()];
+                    case 1:
+                        _a.sent();
                         maxRetries = this.normalizeRetryCount(this.config.maxRetries);
                         retryDelayMs = this.normalizeRetryDelay(this.config.retryDelayMs);
                         lastError = null;
                         modelSequence = this.resolveModelSequence(options);
                         modelIndex = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(modelIndex < modelSequence.length)) return [3 /*break*/, 13];
+                        _a.label = 2;
+                    case 2:
+                        if (!(modelIndex < modelSequence.length)) return [3 /*break*/, 18];
                         model = modelSequence[modelIndex];
                         nextModel = modelSequence[modelIndex + 1];
                         modelOptions = this.applyModelOverride(options, model);
                         attempt = 0;
-                        _a.label = 2;
-                    case 2:
-                        if (!(attempt <= maxRetries)) return [3 /*break*/, 12];
                         _a.label = 3;
                     case 3:
-                        _a.trys.push([3, 9, , 11]);
+                        if (!(attempt <= maxRetries)) return [3 /*break*/, 17];
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 12, , 16]);
                         this.log("run model=".concat(model || this.config.model || 'default', " attempt ").concat(attempt + 1, "/").concat(maxRetries + 1));
-                        if (!(this.pingEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 5];
+                        if (!(this.pingEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 6];
                         return [4 /*yield*/, this.runPing(modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.threadOptions)];
-                    case 4:
-                        _a.sent();
-                        _a.label = 5;
                     case 5:
-                        if (!(this.streamEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 7];
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        if (!(this.streamEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 9];
                         return [4 /*yield*/, this.runStreamedOnce(prompt, modelOptions)];
-                    case 6: return [2 /*return*/, _a.sent()];
-                    case 7: return [4 /*yield*/, this.runOnce(prompt, modelOptions)];
-                    case 8: return [2 /*return*/, _a.sent()];
-                    case 9:
+                    case 7:
+                        result_1 = _a.sent();
+                        return [4 /*yield*/, this.clearModelFallbackPreference(model)];
+                    case 8:
+                        _a.sent();
+                        return [2 /*return*/, result_1];
+                    case 9: return [4 /*yield*/, this.runOnce(prompt, modelOptions)];
+                    case 10:
+                        result = _a.sent();
+                        return [4 /*yield*/, this.clearModelFallbackPreference(model)];
+                    case 11:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                    case 12:
                         error_1 = _a.sent();
                         lastError = error_1;
                         message = error_1 instanceof Error ? error_1.message : String(error_1 || 'Unknown error');
                         this.log("run model=".concat(model || this.config.model || 'default', " attempt ").concat(attempt + 1, " failed: ").concat(message));
-                        if (nextModel && this.isModelAvailabilityError(error_1)) {
-                            this.log("model unavailable; retrying with fallback model ".concat(nextModel));
-                            return [3 /*break*/, 12];
-                        }
+                        if (!(nextModel && this.isModelAvailabilityError(error_1))) return [3 /*break*/, 14];
+                        return [4 /*yield*/, this.rememberModelFallbackPreference(model, nextModel)];
+                    case 13:
+                        _a.sent();
+                        this.log("model unavailable; retrying with fallback model ".concat(nextModel));
+                        return [3 /*break*/, 17];
+                    case 14:
                         if (attempt >= maxRetries || !this.isRetryableError(error_1)) {
                             throw lastError;
                         }
                         delay = retryDelayMs * Math.pow(2, attempt);
                         return [4 /*yield*/, this.sleep(delay)];
-                    case 10:
+                    case 15:
                         _a.sent();
                         attempt += 1;
-                        return [3 /*break*/, 11];
-                    case 11: return [3 /*break*/, 2];
-                    case 12:
+                        return [3 /*break*/, 16];
+                    case 16: return [3 /*break*/, 3];
+                    case 17:
                         modelIndex += 1;
-                        return [3 /*break*/, 1];
-                    case 13: throw lastError;
+                        return [3 /*break*/, 2];
+                    case 18: throw lastError;
                 }
             });
         });
@@ -352,7 +368,7 @@ var CodexClient = /** @class */ (function () {
     };
     CodexClient.prototype.startThread = function (threadOptions_1, threadKey_1) {
         return __awaiter(this, arguments, void 0, function (threadOptions, threadKey, reuseThread) {
-            var mergedOptions, cacheKey, existing, thread_1, thread;
+            var mergedOptions, effectiveModel, cacheKey, existing, thread_1, thread;
             if (reuseThread === void 0) { reuseThread = true; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -360,6 +376,7 @@ var CodexClient = /** @class */ (function () {
                     case 1:
                         _a.sent();
                         mergedOptions = this.mergeThreadOptions(threadOptions);
+                        effectiveModel = (mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.model) || this.config.model || 'default';
                         cacheKey = this.buildThreadCacheKey(threadKey, mergedOptions);
                         if (reuseThread && cacheKey) {
                             existing = this.threadCache.get(cacheKey);
@@ -368,7 +385,7 @@ var CodexClient = /** @class */ (function () {
                                 return [2 /*return*/, existing.thread];
                             }
                         }
-                        this.log("startThread (model=".concat(this.config.model || 'default', ")"));
+                        this.log("startThread (model=".concat(effectiveModel, ")"));
                         if (mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.model) {
                             this.log("startThread options: ".concat(this.formatThreadOptions(mergedOptions)));
                             thread_1 = this.codex.startThread(mergedOptions);
@@ -688,6 +705,11 @@ var CodexClient = /** @class */ (function () {
             }
             sequence.push(normalized);
         };
+        var preferredFallback = this.getModelFallbackPreference(primary);
+        if (preferredFallback) {
+            push(preferredFallback);
+            this.log("sticky model fallback active: ".concat(primary, " -> ").concat(preferredFallback));
+        }
         push(primary);
         fallbackModels.forEach(push);
         if (!fallbackModels.length && primary.toLowerCase().includes('codex')) {
@@ -773,6 +795,195 @@ var CodexClient = /** @class */ (function () {
     CodexClient.prototype.normalizeOptionalString = function (value) {
         return typeof value === 'string' ? value.trim() : '';
     };
+    CodexClient.prototype.resolveModelUnavailableTtlMs = function () {
+        var raw = Number(process.env.AI_DASHBOARD_CODEX_MODEL_UNAVAILABLE_TTL_MS
+            || process.env.AI_ASSISTANT_CODEX_MODEL_UNAVAILABLE_TTL_MS);
+        if (Number.isFinite(raw) && raw >= CodexClient.MIN_MODEL_UNAVAILABLE_TTL_MS) {
+            return Math.floor(raw);
+        }
+        return CodexClient.DEFAULT_MODEL_UNAVAILABLE_TTL_MS;
+    };
+    CodexClient.prototype.ensureModelFallbackPreferencesLoaded = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (CodexClient.modelFallbackPreferencesLoaded) {
+                            this.pruneModelFallbackPreferences();
+                            return [2 /*return*/];
+                        }
+                        if (!(CodexClient.modelFallbackPreferencesLoadPromise !== null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, CodexClient.modelFallbackPreferencesLoadPromise];
+                    case 1:
+                        _a.sent();
+                        this.pruneModelFallbackPreferences();
+                        return [2 /*return*/];
+                    case 2:
+                        CodexClient.modelFallbackPreferencesLoadPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var raw, parsed, _a;
+                            var _this = this;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 2, 3, 4]);
+                                        return [4 /*yield*/, fs_1.promises.readFile(CodexClient.MODEL_UNAVAILABLE_FALLBACK_FILE, 'utf8')];
+                                    case 1:
+                                        raw = _b.sent();
+                                        parsed = JSON.parse(raw);
+                                        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                                            return [2 /*return*/];
+                                        }
+                                        Object.entries(parsed).forEach(function (_a) {
+                                            var _b = __read(_a, 2), model = _b[0], entry = _b[1];
+                                            var key = _this.normalizeOptionalString(model);
+                                            if (!key) {
+                                                return;
+                                            }
+                                            var fallbackModel = _this.normalizeOptionalString(entry === null || entry === void 0 ? void 0 : entry.fallbackModel);
+                                            var expiresAt = Number(entry === null || entry === void 0 ? void 0 : entry.expiresAt);
+                                            var updatedAt = Number(entry === null || entry === void 0 ? void 0 : entry.updatedAt);
+                                            if (!fallbackModel || !Number.isFinite(expiresAt) || expiresAt <= Date.now()) {
+                                                return;
+                                            }
+                                            CodexClient.modelFallbackPreferences.set(key, {
+                                                fallbackModel: fallbackModel,
+                                                expiresAt: Math.floor(expiresAt),
+                                                updatedAt: Number.isFinite(updatedAt) ? Math.floor(updatedAt) : Date.now()
+                                            });
+                                        });
+                                        return [3 /*break*/, 4];
+                                    case 2:
+                                        _a = _b.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        CodexClient.modelFallbackPreferencesLoaded = true;
+                                        CodexClient.modelFallbackPreferencesLoadPromise = null;
+                                        return [7 /*endfinally*/];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        return [4 /*yield*/, CodexClient.modelFallbackPreferencesLoadPromise];
+                    case 3:
+                        _a.sent();
+                        this.pruneModelFallbackPreferences();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CodexClient.prototype.pruneModelFallbackPreferences = function (now) {
+        if (now === void 0) { now = Date.now(); }
+        Array.from(CodexClient.modelFallbackPreferences.entries()).forEach(function (_a) {
+            var _b = __read(_a, 2), model = _b[0], entry = _b[1];
+            if (!entry || !Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) {
+                CodexClient.modelFallbackPreferences.delete(model);
+            }
+        });
+    };
+    CodexClient.prototype.getModelFallbackPreference = function (model) {
+        var normalizedModel = this.normalizeOptionalString(model);
+        if (!normalizedModel) {
+            return '';
+        }
+        this.pruneModelFallbackPreferences();
+        var entry = CodexClient.modelFallbackPreferences.get(normalizedModel);
+        if (!entry || entry.expiresAt <= Date.now()) {
+            if (entry) {
+                CodexClient.modelFallbackPreferences.delete(normalizedModel);
+            }
+            return '';
+        }
+        return entry.fallbackModel;
+    };
+    CodexClient.prototype.rememberModelFallbackPreference = function (model, fallbackModel) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedModel, normalizedFallback, now;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        normalizedModel = this.normalizeOptionalString(model);
+                        normalizedFallback = this.normalizeOptionalString(fallbackModel);
+                        if (!normalizedModel || !normalizedFallback || normalizedModel === normalizedFallback) {
+                            return [2 /*return*/];
+                        }
+                        now = Date.now();
+                        CodexClient.modelFallbackPreferences.set(normalizedModel, {
+                            fallbackModel: normalizedFallback,
+                            expiresAt: now + this.modelUnavailableTtlMs,
+                            updatedAt: now
+                        });
+                        this.pruneModelFallbackPreferences(now);
+                        return [4 /*yield*/, this.persistModelFallbackPreferences()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CodexClient.prototype.clearModelFallbackPreference = function (model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedModel;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        normalizedModel = this.normalizeOptionalString(model);
+                        if (!normalizedModel) {
+                            return [2 /*return*/];
+                        }
+                        if (!CodexClient.modelFallbackPreferences.has(normalizedModel)) {
+                            return [2 /*return*/];
+                        }
+                        CodexClient.modelFallbackPreferences.delete(normalizedModel);
+                        return [4 /*yield*/, this.persistModelFallbackPreferences()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CodexClient.prototype.persistModelFallbackPreferences = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, serialized, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.pruneModelFallbackPreferences();
+                        if (!!CodexClient.modelFallbackPreferences.size) return [3 /*break*/, 5];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, fs_1.promises.unlink(CodexClient.MODEL_UNAVAILABLE_FALLBACK_FILE)];
+                    case 2:
+                        _c.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _c.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                    case 5:
+                        serialized = {};
+                        CodexClient.modelFallbackPreferences.forEach(function (entry, model) {
+                            serialized[model] = entry;
+                        });
+                        _c.label = 6;
+                    case 6:
+                        _c.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, fs_1.promises.writeFile(CodexClient.MODEL_UNAVAILABLE_FALLBACK_FILE, JSON.stringify(serialized), 'utf8')];
+                    case 7:
+                        _c.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _b = _c.sent();
+                        return [3 /*break*/, 9];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
     CodexClient.prototype.sleep = function (ms) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -1089,6 +1300,12 @@ var CodexClient = /** @class */ (function () {
     };
     CodexClient.PING_PROMPT = "Say 'pong'";
     CodexClient.DEFAULT_FALLBACK_MODEL = 'gpt-5.2-codex';
+    CodexClient.MODEL_UNAVAILABLE_FALLBACK_FILE = path.join(os.tmpdir(), 'resolveio-codex-model-fallbacks.json');
+    CodexClient.DEFAULT_MODEL_UNAVAILABLE_TTL_MS = 6 * 60 * 60 * 1000;
+    CodexClient.MIN_MODEL_UNAVAILABLE_TTL_MS = 60 * 1000;
+    CodexClient.modelFallbackPreferences = new Map();
+    CodexClient.modelFallbackPreferencesLoaded = false;
+    CodexClient.modelFallbackPreferencesLoadPromise = null;
     return CodexClient;
 }());
 exports.CodexClient = CodexClient;