@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -49,6 +49,7 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(isConnectionCompatibleWithModel(conn, "gpt-5")).toBe(false);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-nano")).toBe(false);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.5-pro")).toBe(false);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-5.3-codex")).toBe(false);
   });
 
   test("oauth_subscription connection is compatible with a Codex model", () => {
@@ -59,7 +60,6 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.5")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-mini")).toBe(true);
-    expect(isConnectionCompatibleWithModel(conn, "gpt-5.3-codex")).toBe(true);
   });
 
   test("undefined model applies no gating (compatible)", () => {

package/src/providers/__tests__/context-overflow-error.test.ts

@@ -239,6 +239,30 @@ describe("detectOpenAICompatibleContextOverflow", () => {
     expect(detectOpenAICompatibleContextOverflow(err)).toBeNull();
   });
 
+  test("matches OpenAI's per-part 10MiB string_above_max_length 400", () => {
+    const err = buildOpenAIApiError(400, {
+      message:
+        "Invalid 'input[191].content[1].text': string too long. Expected a string with maximum length 10485760, but got a string with length 11436754 instead.",
+      type: "invalid_request_error",
+      code: "string_above_max_length",
+    });
+    const out = detectOpenAICompatibleContextOverflow(err);
+    expect(out).not.toBeNull();
+    // Byte lengths in this message must not be misread as token counts.
+    expect(out?.actualTokens).toBeUndefined();
+    expect(out?.maxTokens).toBeUndefined();
+  });
+
+  test("returns null for string_above_max_length on a non-content field", () => {
+    const err = buildOpenAIApiError(400, {
+      message:
+        "Invalid 'tools[0].function.description': string too long. Expected a string with maximum length 1048576, but got a string with length 2000000 instead.",
+      type: "invalid_request_error",
+      code: "string_above_max_length",
+    });
+    expect(detectOpenAICompatibleContextOverflow(err)).toBeNull();
+  });
+
   test("matches 'too many input tokens' variant emitted by some OpenAI-compatible providers", () => {
     const err = buildOpenAIApiError(400, {
       message: "too many input tokens: 250000",

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -65,6 +65,10 @@ const fakeConnections = new Map<string, Connection>();
 mock.module("../inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) =>
     fakeConnections.get(name) ?? null,
+  listConnections: (_db: unknown, filter?: { provider?: string }) =>
+    Array.from(fakeConnections.values()).filter(
+      (c) => !filter?.provider || c.provider === filter.provider,
+    ),
 }));
 
 mock.module("../registry.js", () => ({
@@ -449,11 +453,43 @@ describe("routing identities", () => {
       },
     } as never);
     expect(resolveProviderCalls[0]?.name).toBe("chatgpt-subscription");
-    // No override needed: the subscription row itself carries provider
-    // "openai", so the adapter resolves from the row.
+    // A pre-migration row carries provider "openai": no override needed, the
+    // adapter resolves from the row.
     expect(resolveProviderCalls[0]?.provider).toBe("openai");
   });
 
+  test("a chatgpt-identity subscription row dispatches with an openai override", async () => {
+    // Migration 366 stamps the row with the "chatgpt" identity; the identity
+    // must never reach adapter construction, so dispatch threads the openai
+    // upstream as providerOverride, mirroring the vellum sentinel.
+    fakeConnections.set("chatgpt-subscription", {
+      name: "chatgpt-subscription",
+      provider: "chatgpt",
+      auth: {
+        type: "oauth_subscription",
+        credential: "credential/chatgpt/access_token",
+      },
+    });
+    fakeProviders.set("conn:chatgpt-subscription", {
+      name: "openai",
+      tag: "subscription",
+    });
+
+    const provider = await tryResolveProviderForConnectionName(
+      "ignored",
+      { llm: {} } as never,
+      "chatgpt",
+      "gpt-5.5",
+    );
+
+    expect(provider?.routeAttribution).toEqual({
+      connectionName: "chatgpt-subscription",
+      isManagedRoute: false,
+    });
+    expect(resolveProviderCalls[0]?.name).toBe("chatgpt-subscription");
+    expect(resolveProviderOpts[0]?.providerOverride).toBe("openai");
+  });
+
   // A second managed row is creatable under any non-reserved name: only the
   // canonical name is refused at the create route, and `provider: "vellum"`
   // derives platform auth. Managed-ness is the row, never its name.
@@ -492,3 +528,179 @@ describe("routing identities", () => {
     ).rejects.toMatchObject({ reason: "not_found" });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Entry-name providers — a profile provider naming a connection row directly.
+// Write surfaces reject these until the entries model enables them; dispatch
+// translates them so hand-edited configs (and the collapse migration later)
+// route through the named row.
+// ---------------------------------------------------------------------------
+
+describe("entry-name providers", () => {
+  beforeEach(() => {
+    resolveProviderCalls.length = 0;
+    resolveProviderOpts.length = 0;
+    fakeConnections.clear();
+    fakeProviders.clear();
+    setConfig("llm", {});
+  });
+
+  test("a profile naming an entry dispatches through that row", async () => {
+    registerConnection(
+      {
+        name: "anthropic-work",
+        provider: "anthropic",
+        auth: {
+          type: "api_key",
+          credential: "credential/anthropic-work/api_key",
+        },
+      },
+      { name: "anthropic", tag: "work-key" },
+    );
+    setLlmConfig({
+      profiles: {
+        work: { provider: "anthropic-work", model: "claude-opus-4-8" },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "work",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls.length).toBe(1);
+    expect(resolveProviderCalls[0]?.name).toBe("anthropic-work");
+    // The label is not a vendor: the row's own provider drives dispatch,
+    // so no override is threaded.
+    expect(resolveProviderOpts[0]?.providerOverride).toBeUndefined();
+  });
+
+  test("a vellum-kind entry derives its upstream from the model", async () => {
+    registerConnection(
+      { name: "work-managed", provider: "vellum", auth: { type: "platform" } },
+      { name: "anthropic", tag: "managed-stub" },
+    );
+    setLlmConfig({
+      profiles: {
+        managed: { provider: "work-managed", model: "claude-opus-4-8" },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "managed",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls[0]?.name).toBe("work-managed");
+    expect(resolveProviderOpts[0]?.providerOverride).toBe("anthropic");
+  });
+
+  test("an entry label alongside an explicit provider_connection still dispatches", async () => {
+    // The step-3 collapse migration rewrites provider to an entry name; a
+    // stale provider_connection left beside it must not fail the vendor
+    // equality against a label that is not a vendor.
+    registerConnection(
+      {
+        name: "anthropic-work",
+        provider: "anthropic",
+        auth: {
+          type: "api_key",
+          credential: "credential/anthropic-work/api_key",
+        },
+      },
+      { name: "anthropic", tag: "work-key" },
+    );
+    setLlmConfig({
+      profiles: {
+        work: {
+          provider: "anthropic-work",
+          provider_connection: "anthropic-work",
+          model: "claude-opus-4-8",
+        },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "work",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls[0]?.name).toBe("anthropic-work");
+    expect(resolveProviderOpts[0]?.providerOverride).toBeUndefined();
+  });
+
+  test("a label with a conflicting provider_connection is held to the label's kind", async () => {
+    // The label's row kind threads as the expected vendor, so a stale or
+    // conflicting connection cannot silently dispatch a different vendor:
+    // the equality mismatch auto-recovers to a row matching the kind.
+    registerConnection(
+      {
+        name: "anthropic-work",
+        provider: "anthropic",
+        auth: {
+          type: "api_key",
+          credential: "credential/anthropic-work/api_key",
+        },
+      },
+      { name: "anthropic", tag: "work-key" },
+    );
+    registerConnection(
+      { name: "ollama-local", provider: "ollama", auth: { type: "none" } },
+      { name: "ollama", tag: "local" },
+    );
+    setLlmConfig({
+      profiles: {
+        conflicted: {
+          provider: "anthropic-work",
+          provider_connection: "ollama-local",
+          model: "claude-opus-4-8",
+        },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "conflicted",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls[0]?.name).toBe("anthropic-work");
+  });
+
+  test("a profile naming no row is healed away at selection", async () => {
+    // Selection treats an unresolvable provider like an incomplete profile:
+    // the broken winner loses and the next rung's model AND transport apply
+    // together, restoring the pre-open-schema self-healing. The anchor is
+    // the managed default, so the heal lands on the vellum route.
+    registerConnection(
+      { name: "vellum", provider: "vellum", auth: { type: "platform" } },
+      { name: "anthropic", tag: "managed-anchor" },
+    );
+    setLlmConfig({
+      profiles: {
+        ghost: { provider: "no-such-entry", model: "claude-opus-4-8" },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "ghost",
+    });
+
+    expect(result).not.toBeNull();
+    expect(resolveProviderCalls[0]?.name).toBe("vellum");
+  });
+
+  test("healing hands off to the anchor, whose own failures stay loud", async () => {
+    // With the broken profile healed away, resolution rests on the managed
+    // anchor; its canonical row missing is a boot-seeding violation and
+    // throws explainably rather than masquerading as the ghost profile.
+    setLlmConfig({
+      profiles: {
+        ghost: { provider: "no-such-entry", model: "claude-opus-4-8" },
+      },
+    });
+
+    await expect(
+      getConfiguredProvider("mainAgent", { overrideProfile: "ghost" }),
+    ).rejects.toMatchObject({ reason: "not_found", connectionName: "vellum" });
+  });
+});

package/src/providers/__tests__/preflight-resolved-config.test.ts

@@ -220,6 +220,63 @@ describe("preflightResolvedConfig", () => {
     ).resolves.toBeUndefined();
   });
 
+  test("an explicit connection outranks an entry-name provider, matching dispatch", async () => {
+    // A healthy entry row must not mask the row the request actually uses.
+    connectionsByName["anthropic-work"] = {
+      name: "anthropic-work",
+      provider: "anthropic",
+      auth: {
+        type: "api_key",
+        credential: "credential/anthropic-work/api_key",
+      },
+    };
+    secureKeys["credential/anthropic-work/api_key"] = "healthy";
+
+    const err = await preflightError(
+      resolved({
+        provider: "anthropic-work",
+        provider_connection: "deleted-row",
+        model: "claude-opus-4-8",
+      }),
+    );
+    expect(err?.reason).toBe("not_found");
+    expect(err?.connectionName).toBe("deleted-row");
+  });
+
+  test("a chatgpt-identity subscription row preflights the same way", async () => {
+    // Migration 366 stamps the row with provider "chatgpt"; preflight judges
+    // its subscription credential, not a provider equality with the openai
+    // upstream.
+    connectionsByName["chatgpt-subscription"] = {
+      name: "chatgpt-subscription",
+      provider: "chatgpt",
+      auth: {
+        type: "oauth_subscription",
+        credential: "credential/chatgpt/access_token",
+      },
+    };
+    const missing = await preflightError(
+      resolved({
+        provider: "chatgpt",
+        provider_connection: "",
+        model: "gpt-5.5",
+      }),
+    );
+    expect(missing?.reason).toBe("missing_credential");
+
+    secureKeys["credential/chatgpt/access_token"] = "tok";
+    await expect(
+      preflightResolvedConfig(
+        resolved({
+          provider: "chatgpt",
+          provider_connection: "",
+          model: "gpt-5.5",
+        }),
+        {},
+      ),
+    ).resolves.toBeUndefined();
+  });
+
   test("a chatgpt identity with no subscription row throws not_found", async () => {
     const err = await preflightError(
       resolved({

package/src/providers/__tests__/retry-callsite.test.ts

@@ -337,7 +337,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.max_tokens).toBe(expected.maxTokens as number);
   });
 
-  test("live-voice front-door call sites reach OpenAI with reasoning off", async () => {
+  test("latency-sensitive live-voice call sites reach OpenAI with reasoning off", async () => {
     // The `latency-optimized` pin's whole value is time-to-first-token, and on
     // an OpenAI upstream that depends entirely on disabled thinking being
     // encoded as `effort: "none"`. OpenAI-compatible APIs reason by default
@@ -351,7 +351,10 @@ describe("RetryProvider — callSite resolution", () => {
     setLlmConfig({});
 
     const expected = CODE_DEFAULT_PROFILE_ENTRIES["latency-optimized"];
-    for (const callSite of ["voiceFrontDoor", "voiceFrontDecision"] as const) {
+    for (const callSite of [
+      "voiceFrontDoor",
+      "voiceProgressNarration",
+    ] as const) {
       let seen: SendMessageOptions | undefined;
       const wrapped = new RetryProvider(
         makeProvider("openai", (options) => {
@@ -367,6 +370,26 @@ describe("RetryProvider — callSite resolution", () => {
     }
   });
 
+  test("memory-v3 selection does not inherit high effort", async () => {
+    setLlmConfig({ defaultProvider: { provider: "anthropic" } });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryV3SelectL2" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.effort).toBe("low");
+    expect(config.thinking).toEqual({ type: "disabled" });
+    expect(config.temperature).toBe(0);
+  });
+
   test("propagates resolved effort/speed/temperature; omits server-side fields", async () => {
     setLlmConfig({
       callSites: {

package/src/providers/anthropic/__tests__/pause-turn-continuation.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+
+import type Anthropic from "@anthropic-ai/sdk";
+
+import { AnthropicProvider, MAX_PAUSE_TURN_CONTINUATIONS } from "../client.js";
+
+function makeMessage(overrides: {
+  stop_reason: Anthropic.Message["stop_reason"];
+  content: Anthropic.ContentBlock[];
+  usage?: Partial<Anthropic.Usage>;
+}): Anthropic.Message {
+  return {
+    id: "msg_test",
+    type: "message",
+    role: "assistant",
+    model: "claude-opus-4-6",
+    stop_sequence: null,
+    content: overrides.content,
+    stop_reason: overrides.stop_reason,
+    usage: {
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_input_tokens: null,
+      cache_read_input_tokens: null,
+      ...overrides.usage,
+    } as Anthropic.Usage,
+  } as Anthropic.Message;
+}
+
+function textBlock(text: string): Anthropic.ContentBlock {
+  return { type: "text", text, citations: null } as Anthropic.ContentBlock;
+}
+
+function serverToolUseBlock(id: string): Anthropic.ContentBlock {
+  return {
+    type: "server_tool_use",
+    id,
+    name: "web_search",
+    input: { query: "test" },
+  } as Anthropic.ContentBlock;
+}
+
+/**
+ * Stub the SDK client on a provider instance. Every stream call records its
+ * params and resolves to the next response in `responses` (repeating the last
+ * one once exhausted). Both the plain and beta endpoints share the recorder —
+ * which endpoint fires depends on the model's beta set.
+ */
+function stubProvider(responses: Anthropic.Message[]): {
+  provider: AnthropicProvider;
+  calls: Anthropic.MessageStreamParams[];
+} {
+  const provider = new AnthropicProvider("test-key", "claude-opus-4-6");
+  const calls: Anthropic.MessageStreamParams[] = [];
+  const stream = (params: Anthropic.MessageStreamParams) => {
+    calls.push(params);
+    const response =
+      responses[Math.min(calls.length - 1, responses.length - 1)];
+    return {
+      on() {
+        return this;
+      },
+      async finalMessage() {
+        return response;
+      },
+    };
+  };
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://api.anthropic.com",
+    messages: { stream },
+    beta: { messages: { stream } },
+  };
+  return { provider, calls };
+}
+
+describe("pause_turn continuation", () => {
+  test("resends the paused assistant content as-is and merges the segments", async () => {
+    const pausedContent = [
+      textBlock("Searching..."),
+      serverToolUseBlock("srvtoolu_1"),
+    ];
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "pause_turn",
+        content: pausedContent,
+        usage: { input_tokens: 10, output_tokens: 5 },
+      }),
+      makeMessage({
+        stop_reason: "end_turn",
+        content: [textBlock("Done")],
+        usage: {
+          input_tokens: 20,
+          output_tokens: 7,
+          cache_creation_input_tokens: 3,
+          cache_read_input_tokens: 4,
+        },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "search something" }] },
+    ]);
+
+    expect(calls.length).toBe(2);
+    // The continuation appends the paused assistant message unchanged.
+    expect(calls[1].messages.length).toBe(calls[0].messages.length + 1);
+    const appended = calls[1].messages[calls[1].messages.length - 1];
+    expect(appended.role).toBe("assistant");
+    expect(appended.content).toBe(pausedContent);
+
+    // Content is the concatenation of the paused segment and the final one.
+    expect(result.content).toEqual([
+      { type: "text", text: "Searching..." },
+      {
+        type: "server_tool_use",
+        id: "srvtoolu_1",
+        name: "web_search",
+        input: { query: "test" },
+      },
+      { type: "text", text: "Done" },
+    ]);
+    expect(result.stopReason).toBe("end_turn");
+
+    // Usage sums across both billed requests (input includes cache tokens).
+    expect(result.usage.inputTokens).toBe(10 + 20 + 3 + 4);
+    expect(result.usage.outputTokens).toBe(12);
+    expect(result.usage.cacheCreationInputTokens).toBe(3);
+    expect(result.usage.cacheReadInputTokens).toBe(4);
+  });
+
+  test("a turn that never pauses issues a single request", async () => {
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "end_turn",
+        content: [textBlock("Hi")],
+        usage: { input_tokens: 8, output_tokens: 2 },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hello" }] },
+    ]);
+
+    expect(calls.length).toBe(1);
+    expect(result.content).toEqual([{ type: "text", text: "Hi" }]);
+    expect(result.stopReason).toBe("end_turn");
+    expect(result.usage.inputTokens).toBe(8);
+    expect(result.usage.cacheCreationInputTokens).toBeUndefined();
+    expect(result.usage.cacheReadInputTokens).toBeUndefined();
+  });
+
+  test("stops resending at the continuation cap and returns the paused response", async () => {
+    const { provider, calls } = stubProvider([
+      makeMessage({
+        stop_reason: "pause_turn",
+        content: [serverToolUseBlock("srvtoolu_stuck")],
+        usage: { input_tokens: 1, output_tokens: 1 },
+      }),
+    ]);
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "search forever" }] },
+    ]);
+
+    expect(calls.length).toBe(1 + MAX_PAUSE_TURN_CONTINUATIONS);
+    expect(result.stopReason).toBe("pause_turn");
+    // Every billed request's usage is accounted for.
+    expect(result.usage.inputTokens).toBe(1 + MAX_PAUSE_TURN_CONTINUATIONS);
+  });
+});