A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
[RSI] fix(coding-agent): wait for model catalog readiness before restore fallback (#2313)
Seth Karten807ff048eb53
diff --git a/packages/coding-agent/.changes/session-restore-model-readiness.md b/packages/coding-agent/.changes/session-restore-model-readiness.mdnew file mode 100644index 0000000000..073cc1a367--- /dev/null+++ b/packages/coding-agent/.changes/session-restore-model-readiness.md@@ -0,0 +1 @@+- Fixed session model restore silently substituting another provider's same-named model right after a daemon restart: restore now waits (bounded, default 5s) for in-flight Prime Inference catalog and private-authorization refreshes to settle and retries the lookup once before falling back, so saved models like prime-inference/openai/gpt-6-astra are restored once auth and the catalog are ready instead of swapping to openai-codex/gpt-6-astra, which displays identically in the UI.diff --git a/packages/coding-agent/src/core/model-registry.ts b/packages/coding-agent/src/core/model-registry.tsindex 8a25bfb037..6c46b5ff3c 100644--- a/packages/coding-agent/src/core/model-registry.ts+++ b/packages/coding-agent/src/core/model-registry.ts@@ -461,6 +461,7 @@ export class ModelRegistry {private openAICodexModelsCache: { authFingerprint: string; modelIds: Set<string>; refreshedAt: number } | undefined;private backgroundPrivatePrimeAuthorization: { fingerprint: string; promise: Promise<void> } | undefined;private livePrimeInferenceModels: Model<"openai-completions">[] | undefined;+ private pendingPrimeInferenceCatalogRefresh: Promise<void> | undefined;private loadError: string | undefined = undefined;/** Re-register dynamic OAuth providers (e.g. user MCP servers) after refresh() resets the registry. */@@ -849,13 +850,23 @@ export class ModelRegistry {this.refresh();const cachePath = this.primeInferenceCatalogCachePath();if (cachePath) {- void refreshPrimeInferenceModels(cachePath, this.bundledPrimeInferenceModels(), {- offline: isOfflineModeEnabled(),- }).then((models) => {- if (!models) return;- this.livePrimeInferenceModels = models;- this.reloadModelsAfterCatalogChange();- });+ // Track the in-flight catalog refresh so waitForPendingModelRefreshes()+ // can await it: session-model restore must observe the post-refresh+ // catalog, not the pre-refresh fallback (bundled/disk snapshot).+ this.pendingPrimeInferenceCatalogRefresh = refreshPrimeInferenceModels(+ cachePath,+ this.bundledPrimeInferenceModels(),+ {+ offline: isOfflineModeEnabled(),+ },+ )+ .then((models) => {+ if (!models) return;+ this.livePrimeInferenceModels = models;+ this.reloadModelsAfterCatalogChange();+ })+ // Settlement, not failure, is what the waiter observes.+ .catch(() => undefined);}await this.refreshPrivatePrimeInferenceAuthorization(previousPrivateModelIds,@@ -866,6 +877,33 @@ export class ModelRegistry {});}+ /**+ * Wait (bounded by timeoutMs) for in-flight Prime Inference catalog and+ * private-authorization refreshes to settle.+ *+ * refreshAvailableModels() returns while the catalog fetch and the stale-cache+ * authorization refresh keep running in the background, so a decision taken+ * right after it can still see pre-refresh state (e.g. restoring a session's+ * saved model on a freshly restarted daemon). Returns immediately when+ * nothing is pending; never waits longer than timeoutMs.+ */+ async waitForPendingModelRefreshes(timeoutMs: number): Promise<void> {+ const pending: Promise<unknown>[] = [];+ if (this.pendingPrimeInferenceCatalogRefresh) pending.push(this.pendingPrimeInferenceCatalogRefresh);+ if (this.backgroundPrivatePrimeAuthorization?.promise) {+ pending.push(this.backgroundPrivatePrimeAuthorization.promise);+ }+ if (pending.length === 0) return;+ await Promise.race([+ Promise.allSettled(pending),+ new Promise<void>((resolve) => {+ const timer = setTimeout(resolve, timeoutMs);+ // The bounded wait must never keep the process alive on its own.+ if (typeof timer.unref === "function") timer.unref();+ }),+ ]);+ }+private entitlementRefreshChain: Promise<unknown> = Promise.resolve();private runSerializedEntitlementRefresh<T>(task: () => Promise<T>): Promise<T> {diff --git a/packages/coding-agent/src/core/model-resolver.ts b/packages/coding-agent/src/core/model-resolver.tsindex 40912439e7..c8f57f7745 100644--- a/packages/coding-agent/src/core/model-resolver.ts+++ b/packages/coding-agent/src/core/model-resolver.ts@@ -16,6 +16,19 @@ const log = getLogger("coding-agent.model-resolver");export const PRIME_INFERENCE_DEFAULT_MODEL_ID = "z-ai/glm-5.3";+/**+ * How long a session-model restore may wait for in-flight Prime Inference+ * catalog and private-authorization refreshes to settle before concluding+ * that a saved model cannot be restored.+ *+ * Right after a daemon restart (e.g. a nightly update) the restore can run+ * before auth storage has been picked up and before the catalog fetch has+ * settled, which would silently substitute another provider's same-named+ * model. The wait is bounded so a genuinely unrestorable model still falls+ * back promptly.+ */+export const SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS = 5_000;+/** Default model IDs for each known provider */export const defaultModelPerProvider: Record<KnownProvider, string> = {"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",@@ -587,6 +600,37 @@ export async function findInitialModel(options: {return { model: undefined, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };}+/**+ * Find a saved session model, giving in-flight catalog/auth refreshes a+ * bounded window to settle before the lookup is allowed to fail.+ *+ * The fast path is a synchronous registry lookup (find ++ * hasConfiguredAuth). Only when that fails do we refresh the registry,+ * wait for the refreshes this call kicked off to settle (bounded by+ * readinessTimeoutMs), and retry the lookup once. A model that still+ * cannot be found after that returns undefined, leaving the caller to+ * fall back to another model.+ */+export async function findSessionModelWithReadinessWait(+ modelRegistry: ModelRegistry,+ provider: string,+ modelId: string,+ readinessTimeoutMs: number = SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,+): Promise<Model<Api> | undefined> {+ const findRestorable = (): Model<Api> | undefined => {+ const registered = modelRegistry.find(provider, modelId);+ return registered && modelRegistry.hasConfiguredAuth(registered) ? registered : undefined;+ };++ const direct = findRestorable();+ if (direct) {+ return direct;+ }+ await modelRegistry.refreshAvailableModels();+ await modelRegistry.waitForPendingModelRefreshes(readinessTimeoutMs);+ return findRestorable();+}+/*** Restore model from session, with fallback to available models*/@@ -596,12 +640,25 @@ export async function restoreModelFromSession(currentModel: Model<Api> | undefined,shouldPrintMessages: boolean,modelRegistry: ModelRegistry,+ readinessTimeoutMs: number = SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,): Promise<{ model: Model<Api> | undefined; fallbackMessage: string | undefined }> {- const availableModels = await modelRegistry.refreshAvailableModels();- const restoredModel = availableModels.find(+ let availableModels = await modelRegistry.refreshAvailableModels();+ let restoredModel = availableModels.find((candidate) => candidate.provider === savedProvider && candidate.id === savedModelId,);+ if (!restoredModel) {+ // refreshAvailableModels() may have resolved while the background catalog+ // fetch or private-authorization refresh was still settling (e.g. right+ // after a daemon restart). Wait for them, then retry the lookup once+ // before concluding the restore failed.+ await modelRegistry.waitForPendingModelRefreshes(readinessTimeoutMs);+ availableModels = await modelRegistry.refreshAvailableModels();+ restoredModel = availableModels.find(+ (candidate) => candidate.provider === savedProvider && candidate.id === savedModelId,+ );+ }+if (restoredModel) {if (shouldPrintMessages) {console.log(chalk.dim(`Restored model: ${savedProvider}/${savedModelId}`));diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.tsindex 105f198f36..4f1f7fd7ed 100644--- a/packages/coding-agent/src/core/sdk.ts+++ b/packages/coding-agent/src/core/sdk.ts@@ -12,7 +12,7 @@ import type { ExtensionRunner, LoadExtensionsResult, SessionStartEvent, ToolDefiimport { McpManager } from "./mcp/mcp-manager.js";import { convertToLlm } from "./messages.js";import { ModelRegistry } from "./model-registry.js";-import { findInitialModel } from "./model-resolver.js";+import { findInitialModel, findSessionModelWithReadinessWait } from "./model-resolver.js";import type { ResourceLoader } from "./resource-loader.js";import { DefaultResourceLoader } from "./resource-loader.js";import { getDefaultSessionDir, SessionManager } from "./session-manager.js";@@ -182,8 +182,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}let modelFallbackMessage: string | undefined;if (!model && hasExistingSession && existingSession.model) {- const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);- if (restoredModel && modelRegistry.hasConfiguredAuth(restoredModel)) {+ // The saved model may be missing only because the Prime Inference+ // catalog/auth refresh has not settled yet (e.g. right after a daemon+ // restart). Give the pending refreshes a bounded window, then retry the+ // lookup once before falling back to another model.+ const restoredModel = await findSessionModelWithReadinessWait(+ modelRegistry,+ existingSession.model.provider,+ existingSession.model.modelId,+ );+ if (restoredModel) {model = restoredModel;}if (!model) {diff --git a/packages/coding-agent/test/suite/regressions/session-restore-model-readiness.test.ts b/packages/coding-agent/test/suite/regressions/session-restore-model-readiness.test.tsnew file mode 100644index 0000000000..5d2c946ee2--- /dev/null+++ b/packages/coding-agent/test/suite/regressions/session-restore-model-readiness.test.ts@@ -0,0 +1,168 @@+import { mkdirSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { getModels } from "@earendil-works/pi-ai";+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";+import { AuthStorage } from "../../../src/core/auth-storage.js";+import { ModelRegistry } from "../../../src/core/model-registry.js";+import { findSessionModelWithReadinessWait, restoreModelFromSession } from "../../../src/core/model-resolver.js";+import { createAgentSession } from "../../../src/core/sdk.js";+import { SessionManager } from "../../../src/core/session-manager.js";++const SAVED_PROVIDER = "prime-inference";+/** A public Prime Inference model that exists only in the (delayed) live catalog. */+const CATALOG_ONLY_MODEL_ID = "openai/gpt-6-astra-canary";+const FALLBACK_MODEL_ID = "z-ai/glm-5.3";++function sleep(ms: number): Promise<void> {+ return new Promise((resolve) => {+ setTimeout(resolve, ms);+ });+}++/**+ * A catalog payload that covers the bundled Prime Inference snapshot (so the+ * fetch survives the coverage check) and additionally contains the+ * catalog-only canary model, which has no bundled template.+ */+function catalogPayloadWithCanary(): unknown {+ const bundledEntries = getModels(SAVED_PROVIDER).map((model) => ({+ id: model.id,+ pricing: { input_usd_per_mtok: 1, output_usd_per_mtok: 1 },+ }));+ return {+ data: [+ ...bundledEntries,+ {+ id: CATALOG_ONLY_MODEL_ID,+ pricing: { input_usd_per_mtok: 1, output_usd_per_mtok: 1 },+ specs: {+ context_window: 200000,+ max_output_tokens: 32000,+ modalities: { input: ["text"], output: ["text"] },+ supports_reasoning: false,+ },+ },+ ],+ };+}++/** Stubs the catalog fetch to resolve with the canary catalog after delayMs. */+function stubDelayedCatalogFetch(delayMs: number): void {+ vi.stubGlobal(+ "fetch",+ vi.fn(async () => {+ await sleep(delayMs);+ return new Response(JSON.stringify(catalogPayloadWithCanary()), { status: 200 });+ }),+ );+}++function primeAuthStorage(): AuthStorage {+ return AuthStorage.inMemory({+ "prime-inference": { type: "api_key", key: "test-key" },+ });+}++function makeTempDir(): string {+ const dir = join(tmpdir(), `pi-restore-readiness-${Date.now()}-${Math.random().toString(36).slice(2)}`);+ mkdirSync(dir, { recursive: true });+ return dir;+}++describe("session model restore waits for catalog readiness", () => {+ const tempDirs: string[] = [];++ beforeEach(() => {+ tempDirs.push(makeTempDir());+ });++ afterEach(() => {+ vi.unstubAllGlobals();+ for (const dir of tempDirs.splice(0)) {+ rmSync(dir, { recursive: true, force: true });+ }+ });++ test("restoreModelFromSession restores a saved model once the delayed catalog refresh settles", async () => {+ stubDelayedCatalogFetch(40);+ const registry = ModelRegistry.create(primeAuthStorage(), join(tempDirs[0]!, "models.json"));++ const restored = await restoreModelFromSession(+ SAVED_PROVIDER,+ CATALOG_ONLY_MODEL_ID,+ undefined,+ false,+ registry,+ 2_000,+ );++ expect(restored.model).toMatchObject({ provider: SAVED_PROVIDER, id: CATALOG_ONLY_MODEL_ID });+ expect(restored.fallbackMessage).toBeUndefined();+ });++ test("restoreModelFromSession falls back to the current model when the bounded wait expires", async () => {+ stubDelayedCatalogFetch(150);+ const registry = ModelRegistry.create(primeAuthStorage(), join(tempDirs[0]!, "models.json"));+ const currentModel = registry.find(SAVED_PROVIDER, FALLBACK_MODEL_ID);+ expect(currentModel).toBeDefined();++ const restored = await restoreModelFromSession(+ SAVED_PROVIDER,+ CATALOG_ONLY_MODEL_ID,+ currentModel,+ false,+ registry,+ 25,+ );++ expect(restored.model).toMatchObject({ provider: SAVED_PROVIDER, id: FALLBACK_MODEL_ID });+ expect(restored.fallbackMessage).toBe(+ `Could not restore model ${SAVED_PROVIDER}/${CATALOG_ONLY_MODEL_ID} (model no longer exists). Using ${SAVED_PROVIDER}/${FALLBACK_MODEL_ID}.`,+ );+ });++ test("findSessionModelWithReadinessWait restores a saved model after the delayed refresh settles", async () => {+ stubDelayedCatalogFetch(40);+ const registry = ModelRegistry.create(primeAuthStorage(), join(tempDirs[0]!, "models.json"));++ const model = await findSessionModelWithReadinessWait(registry, SAVED_PROVIDER, CATALOG_ONLY_MODEL_ID, 2_000);++ expect(model).toMatchObject({ provider: SAVED_PROVIDER, id: CATALOG_ONLY_MODEL_ID });+ });++ test("findSessionModelWithReadinessWait gives up after the bounded wait", async () => {+ stubDelayedCatalogFetch(150);+ const registry = ModelRegistry.create(primeAuthStorage(), join(tempDirs[0]!, "models.json"));++ const model = await findSessionModelWithReadinessWait(registry, SAVED_PROVIDER, CATALOG_ONLY_MODEL_ID, 25);++ expect(model).toBeUndefined();+ });++ test("createAgentSession restores a saved session model once the catalog refresh settles", async () => {+ stubDelayedCatalogFetch(40);+ const cwd = tempDirs[0]!;+ const agentDir = join(cwd, "agent");+ mkdirSync(agentDir, { recursive: true });++ const authStorage = primeAuthStorage();+ const modelRegistry = ModelRegistry.create(authStorage, join(cwd, "models.json"));+ const sessionManager = SessionManager.inMemory(cwd);+ sessionManager.appendMessage({ role: "user", content: "hello", timestamp: Date.now() });+ sessionManager.appendModelChange(SAVED_PROVIDER, CATALOG_ONLY_MODEL_ID);++ const result = await createAgentSession({+ cwd,+ agentDir,+ authStorage,+ modelRegistry,+ sessionManager,+ });++ expect(result.session.model).toMatchObject({ provider: SAVED_PROVIDER, id: CATALOG_ONLY_MODEL_ID });+ expect(result.modelFallbackMessage).toBeUndefined();++ result.session.dispose();+ }, 15_000);+});