@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/{calls/typesafe-noul.ts → providers/jev/ask.ts}

@@ -1,39 +1,53 @@
 /**
- * One bounded yes/no question to TypeSafe's System One model (Jev), shared by
- * the voice judges. A judge runs only when its call site resolves to the
- * TypeSafe provider; every failure comes back as a non-answer so the caller
- * keeps its default behavior.
+ * One bounded question set to TypeSafe's System One model (Jev), shared by
+ * the voice judges and the automatic profile router. A caller runs its
+ * question only when its call site resolves to the TypeSafe provider; every
+ * failure comes back as a non-answer so the caller keeps its default
+ * behavior.
  */
 
-import type { LLMCallSite } from "../config/schemas/llm.js";
-import { type JevJsonValue, noulFromAnswer } from "../providers/jev/client.js";
-import { resolveConfiguredProvider } from "../providers/provider-send-message.js";
-import type { Provider, ProviderResponse } from "../providers/types.js";
-import { getLogger } from "../util/logger.js";
+import type { LLMCallSite } from "../../config/schemas/llm.js";
+import { getLogger } from "../../util/logger.js";
+import { resolveConfiguredProvider } from "../provider-send-message.js";
+import type { Provider, ProviderResponse } from "../types.js";
+import {
+  type JevJsonValue,
+  type JevQuestions,
+  noulFromAnswer,
+} from "./client.js";
 
-const log = getLogger("typesafe-noul");
+const log = getLogger("typesafe-ask");
 
 const TYPESAFE_PROVIDER_NAME = "typesafe";
 
-export type TypesafeNoulOutcome =
-  | "answered"
-  | "unavailable"
-  | "timeout"
-  | "error";
+export type TypesafeOutcome = "answered" | "unavailable" | "timeout" | "error";
+
+export interface TypesafeAskResult {
+  outcome: TypesafeOutcome;
+  /** One entry per question id, present when the outcome is "answered". */
+  answers?: Record<string, unknown>;
+  latencyMs: number;
+}
 
 export interface TypesafeNoulResult {
-  outcome: TypesafeNoulOutcome;
+  outcome: TypesafeOutcome;
   /** Calibrated P(yes), present when the outcome is "answered". */
   noul?: number;
   latencyMs: number;
 }
 
-/** The call site's provider when it resolves to TypeSafe, else null. */
+/**
+ * The call site's provider when it resolves to TypeSafe, else null. Judged
+ * on the dispatched adapter's name rather than the configured provider: a
+ * managed profile is configured as `vellum` and only substitutes the
+ * TypeSafe upstream at dispatch, so the configured name alone would report
+ * the managed Jev profile as unavailable.
+ */
 export async function resolveTypesafeProvider(
   callSite: LLMCallSite,
 ): Promise<Provider | null> {
   const resolved = await resolveConfiguredProvider(callSite);
-  return resolved?.configuredProviderName === TYPESAFE_PROVIDER_NAME
+  return resolved?.provider.name === TYPESAFE_PROVIDER_NAME
     ? resolved.provider
     : null;
 }
@@ -65,21 +79,25 @@ function answersFrom(
   }
 }
 
-/**
- * Ask one noul question. Never rejects. The timeout is a hard race rather
- * than trust in the provider honoring the abort, because callers hold user
- * audio or background work on the answer.
- */
-export async function askTypesafeNoul(args: {
+export interface TypesafeAskArgs {
   callSite: LLMCallSite;
   conversationId: string;
   state: JevJsonValue;
-  instructions: string;
+  questions: JevQuestions;
   timeoutMs: number;
   signal?: AbortSignal;
   /** Defaults to {@link resolveTypesafeProvider} for `callSite`. */
   resolveProvider?: () => Promise<Provider | null>;
-}): Promise<TypesafeNoulResult> {
+}
+
+/**
+ * Ask one question set. Never rejects. The timeout is a hard race rather
+ * than trust in the provider honoring the abort, because callers hold user
+ * audio or a turn's first token on the answer.
+ */
+export async function askTypesafe(
+  args: TypesafeAskArgs,
+): Promise<TypesafeAskResult> {
   const startedAt = Date.now();
   const elapsed = () => Date.now() - startedAt;
   const controller = new AbortController();
@@ -87,7 +105,7 @@ export async function askTypesafeNoul(args: {
     ? AbortSignal.any([args.signal, controller.signal])
     : controller.signal;
 
-  const ask = async (): Promise<TypesafeNoulResult> => {
+  const ask = async (): Promise<TypesafeAskResult> => {
     try {
       const provider = await (
         args.resolveProvider ?? (() => resolveTypesafeProvider(args.callSite))
@@ -104,9 +122,7 @@ export async function askTypesafeNoul(args: {
                 type: "text",
                 text: JSON.stringify({
                   state: args.state,
-                  questions: {
-                    answer: { type: "noul", instructions: args.instructions },
-                  },
+                  questions: args.questions,
                 }),
               },
             ],
@@ -121,20 +137,20 @@ export async function askTypesafeNoul(args: {
           signal,
         },
       );
-      const noul = noulFromAnswer(answersFrom(response)?.answer);
-      if (noul === undefined) {
+      const answers = answersFrom(response);
+      if (answers === null) {
         log.warn(
           { callSite: args.callSite, conversationId: args.conversationId },
-          "TypeSafe judge returned no usable answer",
+          "TypeSafe returned no usable answers",
         );
         return { outcome: "error", latencyMs: elapsed() };
       }
-      return { outcome: "answered", noul, latencyMs: elapsed() };
+      return { outcome: "answered", answers, latencyMs: elapsed() };
     } catch (err) {
       if (!signal.aborted) {
         log.warn(
           { err, callSite: args.callSite, conversationId: args.conversationId },
-          "TypeSafe judge failed",
+          "TypeSafe question failed",
         );
       }
       return { outcome: "error", latencyMs: elapsed() };
@@ -142,7 +158,7 @@ export async function askTypesafeNoul(args: {
   };
 
   let timer: ReturnType<typeof setTimeout> | undefined;
-  const timedOut = new Promise<TypesafeNoulResult>((resolve) => {
+  const timedOut = new Promise<TypesafeAskResult>((resolve) => {
     timer = setTimeout(() => {
       controller.abort();
       resolve({ outcome: "timeout", latencyMs: elapsed() });
@@ -154,3 +170,26 @@ export async function askTypesafeNoul(args: {
     clearTimeout(timer);
   }
 }
+
+/** Ask one yes/no question. Never rejects. */
+export async function askTypesafeNoul(
+  args: Omit<TypesafeAskArgs, "questions"> & { instructions: string },
+): Promise<TypesafeNoulResult> {
+  const { instructions, ...rest } = args;
+  const result = await askTypesafe({
+    ...rest,
+    questions: { answer: { type: "noul", instructions } },
+  });
+  if (result.outcome !== "answered") {
+    return { outcome: result.outcome, latencyMs: result.latencyMs };
+  }
+  const noul = noulFromAnswer(result.answers?.answer);
+  if (noul === undefined) {
+    log.warn(
+      { callSite: args.callSite, conversationId: args.conversationId },
+      "TypeSafe judge returned no usable answer",
+    );
+    return { outcome: "error", latencyMs: result.latencyMs };
+  }
+  return { outcome: "answered", noul, latencyMs: result.latencyMs };
+}

package/src/providers/malformed-tool-call.ts

@@ -0,0 +1,55 @@
+/**
+ * Upstream finish reasons that mean the model tried to call a tool but the
+ * call did not parse.
+ *
+ * Gemini reports these as `MALFORMED_FUNCTION_CALL` (the call was not valid)
+ * and `UNEXPECTED_TOOL_CALL` (a call the request did not allow). The native
+ * Gemini API returns them as `candidate.finishReason`; OpenRouter normalizes
+ * them away in `finish_reason` and passes the raw value through in
+ * `native_finish_reason`. Such responses often carry the tail of the broken
+ * call as plain assistant text, so they must never be taken as a final answer.
+ * Providers throw a status-less `ProviderError` carrying
+ * {@link MALFORMED_TOOL_CALL_MESSAGE}, which the retry layer (`retry.ts`)
+ * resends once with a corrective note.
+ */
+
+import { ProviderError } from "../util/errors.js";
+
+/** Message fragment shared by the provider throw sites and the retry classifier. */
+export const MALFORMED_TOOL_CALL_MESSAGE =
+  "Model emitted a malformed tool call";
+
+const MALFORMED_TOOL_CALL_FINISH_REASONS = new Set([
+  "MALFORMED_FUNCTION_CALL",
+  "UNEXPECTED_TOOL_CALL",
+]);
+
+/**
+ * Whether an upstream finish reason denotes a malformed tool call.
+ * Case- and whitespace-insensitive; a `null`/`undefined`/empty reason is false.
+ */
+export function isMalformedToolCallFinishReason(
+  finishReason: string | null | undefined,
+): boolean {
+  if (!finishReason) {
+    return false;
+  }
+  return MALFORMED_TOOL_CALL_FINISH_REASONS.has(
+    finishReason.trim().toUpperCase(),
+  );
+}
+
+/**
+ * Status-less provider error for a response that ended on a malformed tool
+ * call. The absent status marks it as a stream-content failure, which the
+ * retry layer classifies by message.
+ */
+export function malformedToolCallError(
+  provider: string,
+  finishReason: string,
+): ProviderError {
+  return new ProviderError(
+    `${MALFORMED_TOOL_CALL_MESSAGE} (finish reason: ${finishReason})`,
+    provider,
+  );
+}

package/src/providers/model-catalog.ts

@@ -1,7 +1,9 @@
 import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
 
 export type LongContextMode =
-  "native-model" | "provider-request-option" | "unsupported";
+  | "native-model"
+  | "provider-request-option"
+  | "unsupported";
 
 export interface CatalogModelPricingTier {
   /**
@@ -243,6 +245,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "claude-opus-5-5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "claude-opus-5",
         displayName: "Claude Opus 5",
@@ -454,6 +474,66 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           ],
         },
       },
+      {
+        id: "gpt-6-sol",
+        displayName: "GPT-6 Sol",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "gpt-6-luna",
+        displayName: "GPT-6 Luna",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). cacheRead is the 90% cached-read
       // discount; cacheWrite is the 1.25x-input rate GPT-5.6+ bills for
       // prompt tokens written to the cache (reported as `cache_write_tokens`
@@ -1207,6 +1287,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "anthropic/claude-opus-5.5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-opus-5",
         displayName: "Claude Opus 5",
@@ -1429,6 +1527,126 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           ],
         },
       },
+      {
+        id: "openai/gpt-6-sol",
+        displayName: "GPT-6 Sol",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-sol-pro",
+        displayName: "GPT-6 Sol Pro",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-luna",
+        displayName: "GPT-6 Luna",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-luna-pro",
+        displayName: "GPT-6 Luna Pro",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). The `*-pro` slugs are the same
       // underlying models served with `reasoning.mode: pro` at identical
       // rates. cacheWrite is the 1.25x-input rate GPT-5.6+ bills for prompt
@@ -2140,6 +2358,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "anthropic/claude-opus-5.5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-opus-5",
         displayName: "Claude Opus 5",
@@ -2602,6 +2838,16 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
     supportsPlatformAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
   }));
 
+/**
+ * Providers that are routing identities rather than catalog owners. Mirrors
+ * `ROUTING_IDENTITY_PROVIDERS` in `inference/auth.ts`, which cannot be
+ * imported here without a cycle.
+ */
+const ROUTING_IDENTITY_PROVIDER_IDS: ReadonlySet<string> = new Set([
+  "vellum",
+  "chatgpt",
+]);
+
 /**
  * Whether a catalog model produces free-form chat text. Unlisted providers
  * and model ids default to true so custom endpoints and unknown snapshots
@@ -2614,9 +2860,16 @@ export function catalogModelSupportsText(
   if (typeof provider !== "string" || typeof modelId !== "string") {
     return true;
   }
-  const model = PROVIDER_CATALOG.find((p) => p.id === provider)?.models.find(
-    (m) => m.id === modelId,
-  );
+  // A routing identity ("vellum", "chatgpt") owns no catalog models of the
+  // upstream it dispatches to, so judge the model by its catalog owner: a
+  // managed Jev profile is `vellum` + `jev-latest`, and `jev-latest` opts out
+  // of text under `typesafe`.
+  const catalogProvider = ROUTING_IDENTITY_PROVIDER_IDS.has(provider)
+    ? (getCatalogProviderForModel(modelId) ?? provider)
+    : provider;
+  const model = PROVIDER_CATALOG.find(
+    (p) => p.id === catalogProvider,
+  )?.models.find((m) => m.id === modelId);
   return model?.supportsText !== false;
 }
 

package/src/providers/openai/__tests__/chat-completions-malformed-tool-call.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import { ProviderError } from "../../../util/errors.js";
+import { MALFORMED_TOOL_CALL_MESSAGE } from "../../malformed-tool-call.js";
+import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+
+type MockChunk = {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason?: string | null;
+    native_finish_reason?: string | null;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number };
+};
+
+const MESSAGES = [
+  {
+    role: "user" as const,
+    content: [{ type: "text" as const, text: "upload the cover image" }],
+  },
+];
+
+function stubProvider(chunks: MockChunk[]): OpenAIChatCompletionsProvider {
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "google/gemini-3.8-flash",
+  );
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://openrouter.example.com/api/v1",
+    chat: {
+      completions: {
+        create: async () => ({
+          async *[Symbol.asyncIterator]() {
+            for (const c of chunks) {
+              yield c;
+            }
+          },
+        }),
+      },
+    },
+  };
+  return provider;
+}
+
+function finishChunks(
+  text: string,
+  finishReason: string,
+  nativeFinishReason: string,
+): MockChunk[] {
+  return [
+    { choices: [{ delta: { content: text } }] },
+    {
+      choices: [
+        {
+          delta: {},
+          finish_reason: finishReason,
+          native_finish_reason: nativeFinishReason,
+        },
+      ],
+      usage: { prompt_tokens: 1, completion_tokens: 2 },
+    },
+  ];
+}
+
+describe("OpenAIChatCompletionsProvider malformed tool-call finish", () => {
+  test("throws a status-less malformed tool-call error on native MALFORMED_FUNCTION_CALL", async () => {
+    const provider = stubProvider(
+      finishChunks(
+        ",featuredImage:{_type:image},patch:true}]})",
+        "stop",
+        "MALFORMED_FUNCTION_CALL",
+      ),
+    );
+
+    const error = await provider.sendMessage(MESSAGES).then(
+      () => undefined,
+      (e: unknown) => e,
+    );
+
+    expect(error).toBeInstanceOf(ProviderError);
+    const providerError = error as ProviderError;
+    expect(providerError.statusCode).toBeUndefined();
+    expect(providerError.message).toContain(MALFORMED_TOOL_CALL_MESSAGE);
+    expect(providerError.message).toContain("MALFORMED_FUNCTION_CALL");
+  });
+
+  test("throws on native UNEXPECTED_TOOL_CALL", async () => {
+    const provider = stubProvider(
+      finishChunks("{}", "error", "UNEXPECTED_TOOL_CALL"),
+    );
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      MALFORMED_TOOL_CALL_MESSAGE,
+    );
+  });
+
+  test("returns the response normally on native STOP", async () => {
+    const provider = stubProvider(finishChunks("All done.", "stop", "STOP"));
+
+    const response = await provider.sendMessage(MESSAGES);
+
+    expect(response.stopReason).toBe("stop");
+    expect(response.content).toEqual([{ type: "text", text: "All done." }]);
+  });
+});