@stigmer/runner 3.10.0 → 3.11.1-dev.20260812192248

package/src/shared/__tests__/model-client.test.ts

@@ -53,6 +53,10 @@ describe("buildChatModel", () => {
     vi.clearAllMocks();
     delete process.env.ANTHROPIC_API_KEY;
     delete process.env.OPENAI_API_KEY;
+    delete process.env.STIGMER_ANTHROPIC_BACKEND;
+    delete process.env.STIGMER_OPENAI_BACKEND;
+    delete process.env.CLOUD_ML_REGION;
+    delete process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS;
   });
 
   afterEach(() => {
@@ -159,4 +163,200 @@ describe("buildChatModel", () => {
     expect(provider).toBe("anthropic");
     expect(apiModelId).toBe("claude-haiku-4.5");
   });
+
+  // ─── Request timeout (STIGMER_LLM_REQUEST_TIMEOUT_MS) ──────────────────────
+  //
+  // The timeout lives in a different slot per wrapper: ChatOpenAI reads it
+  // as a constructor field; ChatAnthropic only honors clientOptions.timeout.
+  // Putting it in the shared constructor spread was the regression that made
+  // the env var inert on every Anthropic path (T02 finding 2, repaired in
+  // T06). The backend factories' half of the chain is pinned in the
+  // vertex/bedrock/foundry adapter tests.
+
+  describe("request timeout", () => {
+    it("places the OpenAI timeout at the constructor level with maxRetries 0", async () => {
+      mockRegistryResponse([
+        { id: "gpt-4.1", apiModelId: "gpt-4.1", provider: "openai" },
+      ]);
+
+      await buildChatModel({ modelName: "gpt-4.1", timeoutMs: 5000 });
+
+      const args = mockOpenAICtor.mock.calls.at(-1)?.[0] as Record<string, unknown>;
+      expect(args).toMatchObject({ timeout: 5000, maxRetries: 0 });
+    });
+
+    it("places the Anthropic timeout in clientOptions, never the inert constructor slot", async () => {
+      mockRegistryResponse([
+        { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-haiku-4.5", timeoutMs: 5000 });
+
+      const args = lastAnthropicArgs();
+      expect(args).toMatchObject({ clientOptions: { timeout: 5000 }, maxRetries: 0 });
+      expect(args).not.toHaveProperty("timeout");
+    });
+
+    it("merges the timeout with the proxy wiring inside one clientOptions block", async () => {
+      mockRegistryResponse([
+        { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({
+        modelName: "claude-haiku-4.5",
+        proxyEndpoint: "https://api.stigmer.ai",
+        stigmerToken: "tok-123",
+        timeoutMs: 5000,
+      });
+
+      expect(lastAnthropicArgs()).toMatchObject({
+        clientOptions: {
+          timeout: 5000,
+          baseURL: "https://api.stigmer.ai/v1/proxy/llm/anthropic",
+        },
+      });
+    });
+
+    // The env default resolves INSIDE buildChatModel (#468): before this,
+    // each caller parsed STIGMER_LLM_REQUEST_TIMEOUT_MS itself, and every
+    // caller except the deep-agent main path — including its own sub-agent
+    // modelFactory — dropped the bound.
+    it("defaults to STIGMER_LLM_REQUEST_TIMEOUT_MS when the caller passes no timeout", async () => {
+      process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS = "7000";
+      mockRegistryResponse([
+        { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+      expect(lastAnthropicArgs()).toMatchObject({
+        clientOptions: { timeout: 7000 },
+        maxRetries: 0,
+      });
+    });
+
+    it("lets an explicit caller timeout win over the env default", async () => {
+      process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS = "7000";
+      mockRegistryResponse([
+        { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-haiku-4.5", timeoutMs: 5000 });
+
+      expect(lastAnthropicArgs()).toMatchObject({ clientOptions: { timeout: 5000 } });
+    });
+
+    it.each(["0", "-1", "not-a-number", ""])(
+      "normalizes a non-positive env value (%j) to no bound",
+      async (envValue) => {
+        process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS = envValue;
+        mockRegistryResponse([
+          { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+        ]);
+
+        await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+        const args = lastAnthropicArgs();
+        expect(args).not.toHaveProperty("clientOptions");
+        expect(args).not.toHaveProperty("maxRetries");
+      },
+    );
+  });
+
+  // ─── Provider backends (STIGMER_ANTHROPIC_BACKEND) ─────────────────────────
+
+  describe("vertex backend", () => {
+    beforeEach(() => {
+      process.env.STIGMER_ANTHROPIC_BACKEND = "vertex";
+      process.env.CLOUD_ML_REGION = "asia-south1";
+    });
+
+    it("holds the canonical-id invariant: translated id on the wire, canonical id returned", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.5", apiModelId: "claude-sonnet-4-5-20250929", provider: "anthropic" },
+      ]);
+
+      const { apiModelId } = await buildChatModel({ modelName: "claude-sonnet-4.5" });
+
+      // Pricing and usage metrics key on the canonical id; only the
+      // constructor (the wire) sees the Vertex `@date` form.
+      expect(apiModelId).toBe("claude-sonnet-4-5-20250929");
+      const args = lastAnthropicArgs();
+      expect(args.model).toBe("claude-sonnet-4-5@20250929");
+      expect(typeof args.createClient).toBe("function");
+    });
+
+    it("passes dateless 4.6-generation ids to the wire untranslated", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-sonnet-4.6" });
+
+      expect(lastAnthropicArgs().model).toBe("claude-sonnet-4-6");
+    });
+
+    it("constructs without ANTHROPIC_API_KEY (auth is Google's, not Anthropic's)", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-sonnet-4.6" });
+
+      expect(lastAnthropicArgs().apiKey).toBe("");
+    });
+
+    it("yields to the proxy: a proxied call never consults the backend var", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({
+        modelName: "claude-sonnet-4.6",
+        proxyEndpoint: "https://api.stigmer.ai",
+        stigmerToken: "tok",
+      });
+
+      const args = lastAnthropicArgs();
+      expect(args).not.toHaveProperty("createClient");
+      expect(args.model).toBe("claude-sonnet-4-6");
+      expect(args).toMatchObject({
+        clientOptions: { baseURL: "https://api.stigmer.ai/v1/proxy/llm/anthropic" },
+      });
+    });
+
+    it("leaves the OpenAI path untouched by the Anthropic backend var", async () => {
+      mockRegistryResponse([
+        { id: "gpt-4.1", apiModelId: "gpt-4.1", provider: "openai" },
+      ]);
+
+      await buildChatModel({ modelName: "gpt-4.1" });
+
+      const args = mockOpenAICtor.mock.calls.at(-1)?.[0] as Record<string, unknown>;
+      expect(args).not.toHaveProperty("createClient");
+      expect(mockAnthropicCtor).not.toHaveBeenCalled();
+    });
+
+    it("fails at dispatch with the region message when CLOUD_ML_REGION is missing", async () => {
+      // Defense in depth for paths that bypass the factories' preflight.
+      delete process.env.CLOUD_ML_REGION;
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic" },
+      ]);
+
+      await expect(buildChatModel({ modelName: "claude-sonnet-4.6" }))
+        .rejects.toThrow(/CLOUD_ML_REGION/);
+      expect(mockAnthropicCtor).not.toHaveBeenCalled();
+    });
+  });
+
+  it("throws the parser's message on an invalid backend value (never a silent public fallback)", async () => {
+    process.env.STIGMER_ANTHROPIC_BACKEND = "verteks";
+    mockRegistryResponse([
+      { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic" },
+    ]);
+
+    await expect(buildChatModel({ modelName: "claude-sonnet-4.6" }))
+      .rejects.toThrow(/STIGMER_ANTHROPIC_BACKEND="verteks" is not a supported backend/);
+  });
 });

package/src/shared/__tests__/model-error.test.ts

@@ -11,7 +11,7 @@
  * a non-model error.
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi, afterEach } from "vitest";
 import {
   PLATFORM_CAPACITY_SENTINEL,
   classifyModelCallError,
@@ -211,6 +211,294 @@ describe("classifyModelCallError — connection heuristics and no-signal", () =>
   });
 });
 
+describe("classifyModelCallError — vertex backend", () => {
+  // The Vertex arms activate only for direct-mode Anthropic calls under
+  // STIGMER_ANTHROPIC_BACKEND=vertex (resolved from env, deployment-static).
+  // Every other test in this file runs with the var unset and pins that the
+  // public wordings are untouched.
+  function stubVertexEnv() {
+    vi.stubEnv("STIGMER_ANTHROPIC_BACKEND", "vertex");
+    vi.stubEnv("CLOUD_ML_REGION", "asia-south1");
+  }
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  const vertexCtx = {
+    proxyMode: false,
+    provider: "anthropic" as const,
+    modelId: "claude-sonnet-4-6",
+  };
+
+  it("classifies google-auth credential failures as non-retryable with the GCP fix", () => {
+    stubVertexEnv();
+    for (const raw of [
+      "Could not load the default credentials. Browse to https://cloud.google.com/docs/authentication/getting-started for more information.",
+      "Unable to detect a Project Id in the current environment.",
+      "No projectId was given and it could not be resolved from credentials. The client should be instantiated with the `projectId` option or the `ANTHROPIC_VERTEX_PROJECT_ID` environment variable should be set.",
+      "invalid_grant: Invalid JWT Signature.",
+    ]) {
+      const classified = classifyModelCallError(middlewareWrap(new Error(raw)), vertexCtx);
+      expect(classified?.code, raw).toBe("LLM_BACKEND_CREDENTIALS");
+      expect(classified?.retryable, raw).toBe(false);
+      expect(classified?.message, raw).toContain("GOOGLE_APPLICATION_CREDENTIALS");
+    }
+  });
+
+  it("does NOT classify credential prose when the backend is not vertex (no relabeling drift)", () => {
+    // Same message, backend unset: google-auth prose can only mean vertex —
+    // without it, there is no positive model-call signal, so no classification.
+    const classified = classifyModelCallError(
+      new Error("Could not load the default credentials"),
+      vertexCtx,
+    );
+    expect(classified).toBeUndefined();
+  });
+
+  it("words 401 around Google credentials, not an API key", () => {
+    stubVertexEnv();
+    const classified = classifyModelCallError(sdkError(401, "unauthorized"), vertexCtx);
+    expect(classified?.code).toBe("LLM_AUTHENTICATION_ERROR");
+    expect(classified?.message).toContain("Google rejected this Vertex AI call");
+    expect(classified?.message).not.toContain("API key");
+  });
+
+  it("words 403 around the service account's Vertex AI role", () => {
+    stubVertexEnv();
+    const classified = classifyModelCallError(sdkError(403, "forbidden"), vertexCtx);
+    expect(classified?.code).toBe("LLM_PERMISSION_DENIED");
+    expect(classified?.message).toContain("Vertex AI User");
+    expect(classified?.message).toContain("aiplatform.endpoints.predict");
+  });
+
+  it("words 404 around Model Garden enablement and the configured region", () => {
+    stubVertexEnv();
+    const classified = classifyModelCallError(sdkError(404, "not found"), vertexCtx);
+    expect(classified?.code).toBe("LLM_MODEL_NOT_FOUND");
+    expect(classified?.message).toContain("Model Garden");
+    expect(classified?.message).toContain('region "asia-south1"');
+  });
+
+  it("stays inert in proxy mode even with the backend var set (proxy owns routing)", () => {
+    stubVertexEnv();
+    const classified = classifyModelCallError(
+      sdkError(401, "unauthorized"),
+      { proxyMode: true, provider: "anthropic" },
+    );
+    expect(classified?.message).toContain("Stigmer platform");
+    expect(classified?.message).not.toContain("Vertex");
+  });
+
+  it("stays inert for OpenAI failures with the Anthropic backend var set", () => {
+    stubVertexEnv();
+    const classified = classifyModelCallError(
+      sdkError(404, "not found"),
+      { proxyMode: false, provider: "openai", modelId: "gpt-4.1" },
+    );
+    expect(classified?.message).not.toContain("Vertex");
+  });
+
+  it("never throws on an invalid backend value — classification reads it as public", () => {
+    vi.stubEnv("STIGMER_ANTHROPIC_BACKEND", "verteks");
+    const classified = classifyModelCallError(sdkError(401, "unauthorized"), vertexCtx);
+    expect(classified?.code).toBe("LLM_AUTHENTICATION_ERROR");
+    expect(classified?.message).toContain("API key");
+  });
+});
+
+describe("classifyModelCallError — bedrock backend", () => {
+  // The Bedrock arms activate only for direct-mode Anthropic calls under
+  // STIGMER_ANTHROPIC_BACKEND=bedrock, mirroring the vertex suite above.
+  function stubBedrockEnv() {
+    vi.stubEnv("STIGMER_ANTHROPIC_BACKEND", "bedrock");
+    vi.stubEnv("AWS_REGION", "ap-south-1");
+  }
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  const bedrockCtx = {
+    proxyMode: false,
+    provider: "anthropic" as const,
+    modelId: "claude-sonnet-4-6",
+  };
+
+  it("classifies AWS credential-chain failures as non-retryable with the AWS fix", () => {
+    stubBedrockEnv();
+    for (const raw of [
+      "Could not load credentials from any providers",
+      "Resolved credential object is not valid",
+    ]) {
+      const classified = classifyModelCallError(middlewareWrap(new Error(raw)), bedrockCtx);
+      expect(classified?.code, raw).toBe("LLM_BACKEND_CREDENTIALS");
+      expect(classified?.retryable, raw).toBe(false);
+      expect(classified?.message, raw).toContain("AWS");
+      expect(classified?.message, raw).toContain("AWS_BEARER_TOKEN_BEDROCK");
+    }
+  });
+
+  it("does NOT classify credential prose when the backend is not bedrock (no relabeling drift)", () => {
+    const classified = classifyModelCallError(
+      new Error("Could not load credentials from any providers"),
+      bedrockCtx,
+    );
+    expect(classified).toBeUndefined();
+  });
+
+  it("translates the bare-id inference-profile rejection into the one-var remedy", () => {
+    stubBedrockEnv();
+    // AWS's actual ValidationException prose for newer Claude models
+    // invoked by bare model id.
+    const classified = classifyModelCallError(
+      sdkError(
+        400,
+        "Invocation of model ID anthropic.claude-sonnet-4-6-v1:0 with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model.",
+      ),
+      bedrockCtx,
+    );
+    expect(classified?.code).toBe("LLM_BACKEND_MODEL_ROUTING");
+    expect(classified?.retryable).toBe(false);
+    expect(classified?.message).toContain("STIGMER_BEDROCK_INFERENCE_PREFIX");
+    expect(classified?.message).toContain("STIGMER_BEDROCK_MODEL_MAP");
+  });
+
+  it("words 401 around AWS identity, not an API key", () => {
+    stubBedrockEnv();
+    const classified = classifyModelCallError(sdkError(401, "unauthorized"), bedrockCtx);
+    expect(classified?.code).toBe("LLM_AUTHENTICATION_ERROR");
+    expect(classified?.message).toContain("AWS rejected this Bedrock call");
+    expect(classified?.message).not.toContain("API key");
+  });
+
+  it("words 403 around Bedrock model access and IAM, not an API key", () => {
+    stubBedrockEnv();
+    const classified = classifyModelCallError(sdkError(403, "forbidden"), bedrockCtx);
+    expect(classified?.code).toBe("LLM_PERMISSION_DENIED");
+    expect(classified?.message).toContain("Model access");
+    expect(classified?.message).toContain("bedrock:InvokeModel");
+    expect(classified?.message).not.toContain("API key");
+  });
+
+  it("words 404 around region availability and the id-resolution knobs", () => {
+    stubBedrockEnv();
+    const classified = classifyModelCallError(sdkError(404, "not found"), bedrockCtx);
+    expect(classified?.code).toBe("LLM_MODEL_NOT_FOUND");
+    expect(classified?.message).toContain('region "ap-south-1"');
+    expect(classified?.message).toContain("STIGMER_BEDROCK_MODEL_MAP");
+  });
+
+  it("stays inert in proxy mode even with the backend var set (proxy owns routing)", () => {
+    stubBedrockEnv();
+    const classified = classifyModelCallError(
+      sdkError(401, "unauthorized"),
+      { proxyMode: true, provider: "anthropic" },
+    );
+    expect(classified?.message).toContain("Stigmer platform");
+    expect(classified?.message).not.toContain("Bedrock");
+  });
+
+  it("keeps vertex wordings and bedrock wordings from cross-contaminating", () => {
+    stubBedrockEnv();
+    const classified = classifyModelCallError(sdkError(403, "forbidden"), bedrockCtx);
+    expect(classified?.message).not.toContain("Vertex");
+    expect(classified?.message).not.toContain("Model Garden");
+  });
+});
+
+describe("classifyModelCallError — foundry backend", () => {
+  // The Foundry arms activate only for direct-mode Anthropic calls under
+  // STIGMER_ANTHROPIC_BACKEND=foundry, mirroring the vertex and bedrock
+  // suites above.
+  function stubFoundryEnv() {
+    vi.stubEnv("STIGMER_ANTHROPIC_BACKEND", "foundry");
+    vi.stubEnv("ANTHROPIC_FOUNDRY_RESOURCE", "my-foundry-resource");
+  }
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  const foundryCtx = {
+    proxyMode: false,
+    provider: "anthropic" as const,
+    modelId: "claude-sonnet-4-6",
+  };
+
+  it("classifies Entra token-acquisition failures as non-retryable with the Azure fix", () => {
+    stubFoundryEnv();
+    // The Foundry SDK wraps every token-provider failure in this one
+    // prefix (pinned by foundry-seam.test.ts), so a single wording covers
+    // the whole @azure/identity credential-chain family.
+    const classified = classifyModelCallError(
+      middlewareWrap(
+        new Error(
+          "Failed to get token from azureADTokenProvider: " +
+          "ChainedTokenCredential authentication failed. CredentialUnavailableError: " +
+          "ManagedIdentityCredential: no managed identity endpoint found.",
+        ),
+      ),
+      foundryCtx,
+    );
+    expect(classified?.code).toBe("LLM_BACKEND_CREDENTIALS");
+    expect(classified?.retryable).toBe(false);
+    expect(classified?.message).toContain("Microsoft Entra ID");
+    expect(classified?.message).toContain("ANTHROPIC_FOUNDRY_API_KEY");
+  });
+
+  it("does NOT classify credential prose when the backend is not foundry (no relabeling drift)", () => {
+    const classified = classifyModelCallError(
+      new Error("Failed to get token from azureADTokenProvider: boom"),
+      foundryCtx,
+    );
+    expect(classified).toBeUndefined();
+  });
+
+  it("words 401 around the Foundry credential, not the Anthropic API key", () => {
+    stubFoundryEnv();
+    const classified = classifyModelCallError(sdkError(401, "unauthorized"), foundryCtx);
+    expect(classified?.code).toBe("LLM_AUTHENTICATION_ERROR");
+    expect(classified?.message).toContain("Azure rejected this Microsoft Foundry call");
+    expect(classified?.message).toContain("ANTHROPIC_FOUNDRY_API_KEY");
+    expect(classified?.message).not.toContain("your API key");
+  });
+
+  it("words 403 around the Foundry RBAC role", () => {
+    stubFoundryEnv();
+    const classified = classifyModelCallError(sdkError(403, "forbidden"), foundryCtx);
+    expect(classified?.code).toBe("LLM_PERMISSION_DENIED");
+    expect(classified?.message).toContain("Foundry User");
+    expect(classified?.message).not.toContain("API key");
+  });
+
+  it("words 404 around deployment names, the resource, and the deployment map", () => {
+    stubFoundryEnv();
+    const classified = classifyModelCallError(sdkError(404, "not found"), foundryCtx);
+    expect(classified?.code).toBe("LLM_MODEL_NOT_FOUND");
+    expect(classified?.message).toContain("deployment name");
+    expect(classified?.message).toContain('resource "my-foundry-resource"');
+    expect(classified?.message).toContain("STIGMER_FOUNDRY_DEPLOYMENT_MAP");
+  });
+
+  it("stays inert in proxy mode even with the backend var set (proxy owns routing)", () => {
+    stubFoundryEnv();
+    const classified = classifyModelCallError(
+      sdkError(401, "unauthorized"),
+      { proxyMode: true, provider: "anthropic" },
+    );
+    expect(classified?.message).toContain("Stigmer platform");
+    expect(classified?.message).not.toContain("Foundry");
+  });
+
+  it("keeps foundry wordings from cross-contaminating with the other backends", () => {
+    stubFoundryEnv();
+    const classified = classifyModelCallError(sdkError(404, "not found"), foundryCtx);
+    expect(classified?.message).not.toContain("Vertex");
+    expect(classified?.message).not.toContain("Bedrock");
+  });
+});
+
 describe("describeExecutionError", () => {
   it("labels classified model errors with the stable code, not the wrapper class", () => {
     const { errorType, errorMessage } = describeExecutionError(

package/src/shared/__tests__/model-pricing.test.ts

@@ -1,6 +1,11 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { computeLlmCostMicros, computeTurnCost, getModelPricing, resolveModelId, ensureLoaded } from "../model-pricing.js";
-import type { ModelPricing } from "../model-pricing-data.js";
+import {
+  getPricingTable,
+  _resetPricingCache,
+  DEFAULT_PRICING,
+  type ModelPricing,
+} from "../model-pricing-data.js";
 
 describe("computeLlmCostMicros", () => {
   it("falls back to DEFAULT_PRICING when registry is not loaded", () => {
@@ -83,3 +88,58 @@ describe("getModelPricing", () => {
     expect(pricing.model).toBe("custom-model");
   });
 });
+
+describe("getPricingTable failure caching (#468)", () => {
+  beforeEach(() => {
+    _resetPricingCache();
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    _resetPricingCache();
+    vi.useRealTimers();
+  });
+
+  const registryResponse = () =>
+    new Response(
+      JSON.stringify({
+        models: [
+          {
+            id: "claude-sonnet-4-6",
+            displayName: "Claude Sonnet",
+            costTier: "standard",
+            pricing: {
+              inputPricePerMillion: 3.0,
+              outputPricePerMillion: 15.0,
+              cacheWritePricePerMillion: 3.75,
+              cacheReadPricePerMillion: 0.3,
+            },
+          },
+        ],
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+
+  it("retries after the short failure TTL instead of pinning DEFAULT_PRICING for an hour", async () => {
+    // The model-registry.ts failure-cache policy, applied here: wrong default
+    // rates for cost tracking must not persist a full success TTL.
+    vi.useFakeTimers();
+    const fetchSpy = vi
+      .spyOn(globalThis, "fetch")
+      .mockRejectedValueOnce(new Error("network error"))
+      .mockResolvedValueOnce(registryResponse());
+
+    // First call fails and degrades to the default table.
+    expect((await getPricingTable())[0]).toBe(DEFAULT_PRICING);
+
+    // Within the failure TTL the fallback stays cached (no refetch).
+    vi.advanceTimersByTime(30_000);
+    expect((await getPricingTable())[0]).toBe(DEFAULT_PRICING);
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+
+    // Past the failure TTL the registry is refetched and real rates recover.
+    vi.advanceTimersByTime(31_000);
+    expect((await getPricingTable())[0]?.model).toBe("claude-sonnet-4-6");
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/shared/__tests__/model-registry.test.ts

@@ -223,6 +223,28 @@ describe("resolveToApiModelId", () => {
     expect(result).toBe("claude-haiku-4.5");
   });
 
+  it("recovers from a transient network failure without engaging the failure cache (#468)", async () => {
+    // undici's retryable shape (TypeError) — the shared bounded-backoff loop
+    // absorbs it, so resolution succeeds on the SAME call and the 60 s
+    // degraded window never opens. Pre-#468 code failed the fetch outright.
+    const fetchSpy = vi
+      .spyOn(globalThis, "fetch")
+      .mockRejectedValueOnce(new TypeError("fetch failed"))
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            models: [
+              { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic", costTier: "economy", harness: "native" },
+            ],
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        ),
+      );
+
+    expect(await resolveToApiModelId("claude-haiku-4.5")).toBe("claude-haiku-4-5-20251001");
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+  });
+
   it("retries after the short failure TTL instead of caching the failure for an hour", async () => {
     vi.useFakeTimers();
     const fetchSpy = vi

package/src/shared/__tests__/synthesized-attachment.test.ts

@@ -40,6 +40,7 @@ const userServer: ResolvedMcpServer = {
   url: "https://example.com",
   toolApprovals: [],
   pinnedToolApprovals: [],
+  toolApprovalOverrides: [],
   discoveredCapabilitiesEmpty: false,
 };