Skip to content

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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, ToolDefi
import { 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.ts
new file mode 100644
index 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);
+});