@resolveio/server-lib 22.0.10 → 22.0.12

package/package.json

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

package/services/codex-client.d.ts

@@ -2,6 +2,8 @@ export interface CodexConfig {
     apiKey?: string;
     baseUrl?: string;
     model?: string;
+    fallbackModel?: string;
+    fallbackModels?: string[];
     maxRetries?: number;
     retryDelayMs?: number;
 }
@@ -12,6 +14,7 @@ export interface CodexRunOptions {
     threadOptions?: CodexThreadOptions;
     threadKey?: string;
     reuseThread?: boolean;
+    fallbackModels?: string[];
     onStreamEvent?: StreamEventHandler;
     onStreamText?: StreamTextHandler;
 }
@@ -29,6 +32,13 @@ 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;
@@ -39,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);
@@ -54,7 +65,20 @@ export declare class CodexClient {
     private withTimeout;
     private normalizeRetryCount;
     private normalizeRetryDelay;
+    private resolveModelSequence;
+    private collectFallbackModels;
+    private normalizeModelList;
+    private applyModelOverride;
+    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,46 +116,78 @@ var CodexClient = /** @class */ (function () {
     }
     CodexClient.prototype.run = function (prompt, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var maxRetries, retryDelayMs, attempt, lastError, 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);
-                        attempt = 0;
                         lastError = null;
-                        if (!(this.pingEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.runPing(options === null || options === void 0 ? void 0 : options.threadOptions)];
-                    case 1:
-                        _a.sent();
+                        modelSequence = this.resolveModelSequence(options);
+                        modelIndex = 0;
                         _a.label = 2;
                     case 2:
-                        if (!(attempt <= maxRetries)) return [3 /*break*/, 10];
+                        if (!(modelIndex < modelSequence.length)) return [3 /*break*/, 18];
+                        model = modelSequence[modelIndex];
+                        nextModel = modelSequence[modelIndex + 1];
+                        modelOptions = this.applyModelOverride(options, model);
+                        attempt = 0;
                         _a.label = 3;
                     case 3:
-                        _a.trys.push([3, 7, , 9]);
-                        this.log("run attempt ".concat(attempt + 1, "/").concat(maxRetries + 1));
-                        if (!(this.streamEnabled && !this.isPingPrompt(prompt))) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.runStreamedOnce(prompt, options)];
-                    case 4: return [2 /*return*/, _a.sent()];
-                    case 5: return [4 /*yield*/, this.runOnce(prompt, options)];
-                    case 6: return [2 /*return*/, _a.sent()];
+                        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*/, 6];
+                        return [4 /*yield*/, this.runPing(modelOptions === null || modelOptions === void 0 ? void 0 : modelOptions.threadOptions)];
+                    case 5:
+                        _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 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 attempt ".concat(attempt + 1, " failed: ").concat(message));
+                        this.log("run model=".concat(model || this.config.model || 'default', " attempt ").concat(attempt + 1, " failed: ").concat(message));
+                        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)) {
-                            return [3 /*break*/, 10];
+                            throw lastError;
                         }
                         delay = retryDelayMs * Math.pow(2, attempt);
                         return [4 /*yield*/, this.sleep(delay)];
-                    case 8:
+                    case 15:
                         _a.sent();
                         attempt += 1;
-                        return [3 /*break*/, 9];
-                    case 9: return [3 /*break*/, 2];
-                    case 10: throw lastError;
+                        return [3 /*break*/, 16];
+                    case 16: return [3 /*break*/, 3];
+                    case 17:
+                        modelIndex += 1;
+                        return [3 /*break*/, 2];
+                    case 18: throw lastError;
                 }
             });
         });
@@ -335,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) {
@@ -343,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);
@@ -351,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);
@@ -658,6 +692,95 @@ var CodexClient = /** @class */ (function () {
         }
         return Math.max(100, Math.floor(value));
     };
+    CodexClient.prototype.resolveModelSequence = function (options) {
+        var _this = this;
+        var _a;
+        var primary = this.normalizeOptionalString(((_a = options === null || options === void 0 ? void 0 : options.threadOptions) === null || _a === void 0 ? void 0 : _a.model) || this.config.model);
+        var fallbackModels = this.collectFallbackModels(options === null || options === void 0 ? void 0 : options.fallbackModels);
+        var sequence = [];
+        var push = function (value) {
+            var normalized = _this.normalizeOptionalString(value);
+            if (!normalized || sequence.includes(normalized)) {
+                return;
+            }
+            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')) {
+            push(CodexClient.DEFAULT_FALLBACK_MODEL);
+        }
+        if (!sequence.length) {
+            sequence.push('');
+        }
+        return sequence;
+    };
+    CodexClient.prototype.collectFallbackModels = function (runFallbackModels) {
+        var _this = this;
+        var models = [];
+        var push = function (value) {
+            var normalized = _this.normalizeOptionalString(value);
+            if (!normalized || models.includes(normalized)) {
+                return;
+            }
+            models.push(normalized);
+        };
+        this.normalizeModelList(runFallbackModels).forEach(push);
+        this.normalizeModelList(this.config.fallbackModels).forEach(push);
+        push(this.config.fallbackModel);
+        this.normalizeModelList(process.env.AI_ASSISTANT_CODEX_FALLBACK_MODELS).forEach(push);
+        push(process.env.AI_ASSISTANT_CODEX_FALLBACK_MODEL);
+        this.normalizeModelList(process.env.AI_TERMINAL_CODEX_FALLBACK_MODELS).forEach(push);
+        push(process.env.AI_TERMINAL_CODEX_FALLBACK_MODEL);
+        this.normalizeModelList(process.env.AI_DASHBOARD_CODEX_FALLBACK_MODELS).forEach(push);
+        push(process.env.AI_DASHBOARD_CODEX_FALLBACK_MODEL);
+        return models;
+    };
+    CodexClient.prototype.normalizeModelList = function (value) {
+        var _this = this;
+        if (Array.isArray(value)) {
+            return value
+                .map(function (entry) { return _this.normalizeOptionalString(entry); })
+                .filter(Boolean);
+        }
+        var raw = this.normalizeOptionalString(value);
+        if (!raw) {
+            return [];
+        }
+        return raw
+            .split(',')
+            .map(function (entry) { return _this.normalizeOptionalString(entry); })
+            .filter(Boolean);
+    };
+    CodexClient.prototype.applyModelOverride = function (options, model) {
+        var nextThreadOptions = __assign({}, ((options === null || options === void 0 ? void 0 : options.threadOptions) || {}));
+        if (model) {
+            nextThreadOptions.model = model;
+        }
+        else {
+            delete nextThreadOptions.model;
+        }
+        return __assign(__assign({}, (options || {})), { threadOptions: nextThreadOptions });
+    };
+    CodexClient.prototype.isModelAvailabilityError = function (error) {
+        var message = error instanceof Error ? error.message : String(error || '');
+        var normalized = message.toLowerCase();
+        if (!normalized.includes('model')) {
+            return false;
+        }
+        if (/does not exist|not found|unknown model|invalid model|unsupported model|model_not_found|no such model/.test(normalized)) {
+            return true;
+        }
+        if (/not available|unavailable|not enabled|not allowed|do not have access|don't have access|insufficient permissions/.test(normalized)) {
+            return true;
+        }
+        return /404/.test(normalized) && /model/.test(normalized);
+    };
     CodexClient.prototype.isRetryableError = function (error) {
         var message = error instanceof Error ? error.message : String(error || '');
         if (/Codex returned no completion content/i.test(message)) {
@@ -669,6 +792,198 @@ var CodexClient = /** @class */ (function () {
         }
         return /ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|fetch failed|timed out|timeout/i.test(message);
     };
+    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) {
@@ -984,6 +1299,13 @@ 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;