@stigmer/runner 3.9.0 → 3.11.0

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-registry.test.ts

@@ -3,6 +3,7 @@ import {
   getSummarizationModel,
   getEconomyModel,
   getDefaultModel,
+  getModelVisionCapability,
   resolveToApiModelId,
   _resetRegistryCache,
 } from "../model-registry.js";
@@ -253,6 +254,75 @@ describe("resolveToApiModelId", () => {
   });
 });
 
+describe("getModelVisionCapability", () => {
+  beforeEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+  });
+
+  it("returns the explicit vision flag when the capabilities block is present", async () => {
+    mockRegistryResponse([
+      { id: "claude-sonnet-4.6", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { vision: true, toolUse: true } },
+      { id: "llama3.1", provider: "ollama", costTier: "economy", harness: "native", capabilities: { vision: false, toolUse: true } },
+    ]);
+
+    expect(await getModelVisionCapability("claude-sonnet-4.6")).toBe(true);
+    _resetRegistryCache();
+    mockRegistryResponse([
+      { id: "llama3.1", provider: "ollama", costTier: "economy", harness: "native", capabilities: { vision: false } },
+    ]);
+    expect(await getModelVisionCapability("llama3.1")).toBe(false);
+  });
+
+  it("returns undefined when the capabilities block is absent (never assessed ≠ blind)", async () => {
+    // The cursor-harness convention today: pricing + UI fields, no
+    // capabilities block. Must stay undefined, never coerce to false.
+    mockRegistryResponse([
+      { id: "composer-2.5", provider: "cursor", costTier: "economy", harness: "cursor" },
+    ]);
+
+    expect(await getModelVisionCapability("composer-2.5")).toBeUndefined();
+  });
+
+  it("matches by apiModelId as well as registry id", async () => {
+    // getDefaultModel() hands the deep-agent harness the provider API id, so
+    // both identifier forms must resolve to the same capability.
+    mockRegistryResponse([
+      { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { vision: true } },
+    ]);
+
+    expect(await getModelVisionCapability("claude-sonnet-4-6")).toBe(true);
+  });
+
+  it("returns undefined for unknown names, the empty string, and the Auto pool", async () => {
+    mockRegistryResponse([
+      { id: "claude-sonnet-4.6", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { vision: true } },
+    ]);
+
+    expect(await getModelVisionCapability("never-heard-of-it")).toBeUndefined();
+    expect(await getModelVisionCapability("")).toBeUndefined();
+    expect(await getModelVisionCapability("default")).toBeUndefined();
+  });
+
+  it("returns undefined when the registry fetch fails (fail-open)", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValueOnce(new Error("network error"));
+
+    expect(await getModelVisionCapability("claude-sonnet-4.6")).toBeUndefined();
+  });
+
+  it("treats a malformed capabilities value as undefined", async () => {
+    mockRegistryResponse([
+      { id: "weird-model", provider: "anthropic", costTier: "standard", harness: "native", capabilities: "yes" as unknown as { vision?: boolean } },
+    ]);
+
+    expect(await getModelVisionCapability("weird-model")).toBeUndefined();
+  });
+});
+
 interface MockModel {
   id: string;
   apiModelId?: string;
@@ -260,6 +330,7 @@ interface MockModel {
   costTier: string;
   harness: string;
   featured?: boolean;
+  capabilities?: { vision?: boolean; toolUse?: boolean };
 }
 
 function mockRegistryResponse(models: MockModel[]) {

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

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

package/src/shared/__tests__/vertex-adapter.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Adapter test for the vertex backend branch of buildChatModel — the
+ * complement of vertex-seam.test.ts.
+ *
+ * The seam test pins the REAL AnthropicVertex client's wire behavior under
+ * a hand-built ChatAnthropic. This file pins OUR production wiring: a real
+ * `buildChatModel` and a real `ChatAnthropic` drive a mocked
+ * `@anthropic-ai/vertex-sdk`, so LangChain's lazy `createClient` invocation
+ * path (client constructed on first request, once per cached client) is
+ * exercised exactly as production does it. Together the two files cover the
+ * whole chain without any test-only injection seam in production code.
+ *
+ * Pinned here:
+ * - the factory forwards LangChain's `maxRetries: 0` to the client (a
+ *   factory that drops it nests SDK retries inside LangChain's own loop),
+ * - the factory forwards the request timeout (clientOptions.timeout ->
+ *   factory options -> SDK constructor; how STIGMER_LLM_REQUEST_TIMEOUT_MS
+ *   bounds this backend),
+ * - construction and invocation succeed with NO ANTHROPIC_API_KEY (Vertex
+ *   auth is Google's, and ChatAnthropic waives the key when createClient
+ *   is provided),
+ * - the translated `@date` id is what crosses the wire while the returned
+ *   apiModelId stays canonical (the canonical-id invariant),
+ * - usage_metadata survives the adapter (what billing reads).
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { HumanMessage, AIMessage } from "@langchain/core/messages";
+
+const { vertexCtorArgs, createRequests } = vi.hoisted(() => ({
+  vertexCtorArgs: [] as Array<{ maxRetries?: number; timeout?: number }>,
+  createRequests: [] as Array<Record<string, unknown>>,
+}));
+
+vi.mock("@anthropic-ai/vertex-sdk", () => ({
+  AnthropicVertex: class {
+    readonly maxRetries: number | undefined;
+    readonly messages = {
+      create: async (request: Record<string, unknown>) => {
+        createRequests.push(request);
+        return {
+          id: "msg_vertex_adapter_01",
+          type: "message",
+          role: "assistant",
+          model: request.model,
+          content: [{ type: "text", text: "Namaste from Vertex." }],
+          stop_reason: "end_turn",
+          stop_sequence: null,
+          usage: { input_tokens: 7, output_tokens: 5 },
+        };
+      },
+    };
+
+    constructor(opts: { maxRetries?: number; timeout?: number }) {
+      vertexCtorArgs.push(opts);
+      this.maxRetries = opts.maxRetries;
+    }
+  },
+}));
+
+import { ChatAnthropic } from "@langchain/anthropic";
+
+import { buildChatModel } from "../model-client.js";
+import { _resetRegistryCache } from "../model-registry.js";
+import { toVertexModelId } from "../llm-backend.js";
+
+describe("buildChatModel vertex adapter", () => {
+  const savedEnv = { ...process.env };
+
+  beforeEach(() => {
+    _resetRegistryCache();
+    vertexCtorArgs.length = 0;
+    createRequests.length = 0;
+    delete process.env.ANTHROPIC_API_KEY;
+    process.env.STIGMER_ANTHROPIC_BACKEND = "vertex";
+    process.env.CLOUD_ML_REGION = "asia-south1";
+    // Registry offline → resolveToApiModelId passes the id through, keeping
+    // this test free of registry fixtures (that path has its own tests).
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("registry offline"));
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+    process.env = { ...savedEnv };
+  });
+
+  it("drives the mocked client through the real createClient path with the invariants intact", async () => {
+    const { model, apiModelId } = await buildChatModel({
+      modelName: "claude-sonnet-4-5-20250929",
+      maxTokens: 1024,
+    });
+
+    // Canonical id returned; the client is not constructed yet (lazy factory).
+    expect(apiModelId).toBe("claude-sonnet-4-5-20250929");
+    expect(vertexCtorArgs).toHaveLength(0);
+
+    const result = await model.invoke([new HumanMessage("Weather in Chennai?")]);
+
+    // First request constructed exactly one (batch) client, with LangChain's
+    // maxRetries: 0 honored — LangChain owns retrying.
+    expect(vertexCtorArgs).toHaveLength(1);
+    expect(vertexCtorArgs[0].maxRetries).toBe(0);
+
+    // The wire carries the Vertex-translated id; billing already got the
+    // canonical one above.
+    expect(createRequests).toHaveLength(1);
+    expect(createRequests[0].model).toBe("claude-sonnet-4-5@20250929");
+    expect(createRequests[0].max_tokens).toBe(1024);
+
+    // Response and usage flow back through LangChain untouched.
+    expect(result).toBeInstanceOf(AIMessage);
+    expect(result.text).toBe("Namaste from Vertex.");
+    expect((result as AIMessage).usage_metadata).toMatchObject({
+      input_tokens: 7,
+      output_tokens: 5,
+      total_tokens: 12,
+    });
+  });
+
+  it("translated ids inherit the same default maxTokens as canonical ids", () => {
+    // setup.ts deliberately omits maxTokens, so the LangChain per-model
+    // default applies. That default prefix-matches the model string — and the
+    // vertex branch hands ChatAnthropic the TRANSLATED string. This pins the
+    // equality the zero-behavior-change criterion rests on (verified 16384 ==
+    // 16384 for 4.5-generation ids at @langchain/anthropic 1.4.0); a future
+    // bump that diverges the two forms fails here instead of silently capping
+    // vertex deployments differently from public ones.
+    for (const canonical of [
+      "claude-sonnet-4-5-20250929",
+      "claude-haiku-4-5-20251001",
+      "claude-sonnet-4-6",
+    ]) {
+      const publicModel = new ChatAnthropic({ model: canonical, apiKey: "probe" });
+      const vertexModel = new ChatAnthropic({ model: toVertexModelId(canonical), apiKey: "probe" });
+      expect(vertexModel.maxTokens, canonical).toBe(publicModel.maxTokens);
+    }
+  });
+
+  it("forwards the request timeout to the SDK client (STIGMER_LLM_REQUEST_TIMEOUT_MS path)", async () => {
+    // The timeout rides clientOptions -> factory options -> SDK constructor.
+    // A factory that drops it silently unbounds the operator's timeout on
+    // this backend (the regression T06 repaired for the public path).
+    const { model } = await buildChatModel({
+      modelName: "claude-sonnet-4-6",
+      maxTokens: 256,
+      timeoutMs: 5000,
+    });
+    await model.invoke([new HumanMessage("hi")]);
+
+    expect(vertexCtorArgs).toHaveLength(1);
+    expect(vertexCtorArgs[0].timeout).toBe(5000);
+    expect(vertexCtorArgs[0].maxRetries).toBe(0);
+  });
+
+  it("constructs and invokes with no ANTHROPIC_API_KEY anywhere in the environment", async () => {
+    expect(process.env.ANTHROPIC_API_KEY).toBeUndefined();
+
+    const { model } = await buildChatModel({
+      modelName: "claude-sonnet-4-6",
+      maxTokens: 256,
+    });
+    const result = await model.invoke([new HumanMessage("hi")]);
+
+    expect(result).toBeInstanceOf(AIMessage);
+    // Dateless 4.6-generation id crossed the wire untranslated.
+    expect(createRequests.at(-1)?.model).toBe("claude-sonnet-4-6");
+  });
+});