@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/plugins/defaults/memory/v3/__tests__/pool-select.test.ts

@@ -39,7 +39,6 @@ import type {
   SendMessageOptions,
 } from "@vellumai/plugin-api";
 
-import { OpenRouterProvider } from "../../../../../providers/openrouter/client.js";
 import { ProviderError } from "../../../../../util/errors.js";
 import { sectionHeadLine } from "../sections.js";
 import type { MemoryRoutingTurn, Section } from "../types.js";
@@ -844,91 +843,3 @@ describe("selectPool: sections and keyword-in-context snippets", () => {
     );
   });
 });
-
-// ---------------------------------------------------------------------------
-// selectPool: cataloged thinking and forced-tool compatibility.
-// ---------------------------------------------------------------------------
-
-describe("selectPool: cataloged thinking and forced-tool compatibility", () => {
-  test("OpenRouter Kimi K2.6 omits the forced choice and yields a structured selection", async () => {
-    // A real OpenAI chat-completions provider stands in for the cataloged
-    // OpenRouter Kimi profile. The request succeeds without a reactive retry
-    // because the forced select_pages choice is omitted before dispatch.
-    const wireRequests: unknown[] = [];
-    const kimi = new OpenRouterProvider(
-      "test-key",
-      "moonshotai/kimi-k2.6-20260420",
-    );
-    (kimi as unknown as { client: unknown }).client = {
-      chat: {
-        completions: {
-          create: async (params: unknown) => {
-            wireRequests.push(JSON.parse(JSON.stringify(params)));
-            return {
-              async *[Symbol.asyncIterator]() {
-                yield {
-                  choices: [
-                    {
-                      delta: {
-                        tool_calls: [
-                          {
-                            index: 0,
-                            id: "call-1",
-                            function: {
-                              name: "select_pages",
-                              arguments: '{"ids":[3]}',
-                            },
-                          },
-                        ],
-                      },
-                      finish_reason: "tool_calls",
-                    },
-                  ],
-                  usage: { prompt_tokens: 10, completion_tokens: 2 },
-                };
-              },
-            };
-          },
-        },
-      },
-    };
-
-    // The profile layer injects the thinking effort onto the call config in
-    // production; emulate that here so the forced tool_choice rides alongside
-    // reasoning on the wire.
-    providerStub = {
-      name: "kimi-openai-compat",
-      sendMessage: (messages: Message[], options?: SendMessageOptions) =>
-        kimi.sendMessage(messages, {
-          ...options,
-          config: {
-            ...options?.config,
-            effort: "high",
-            thinking: { enabled: true },
-          },
-        }),
-    };
-
-    const selection = await selectPool(makePool(), makeTurn("rollout?"));
-
-    // The preflight path avoids an incompatible first request, and the
-    // pool-level re-prompt loop never engages.
-    expect(wireRequests).toHaveLength(1);
-    const first = wireRequests[0] as {
-      tool_choice?: unknown;
-      reasoning?: { effort?: string; summary?: string };
-    };
-    expect(first.tool_choice).toBeUndefined();
-    expect(first.reasoning).toMatchObject({
-      effort: "high",
-      summary: "detailed",
-    });
-    expect(
-      warnPayloads().filter((p) => p.reason === "provider_error"),
-    ).toEqual([]);
-
-    // Structured selection survived: ids [3] is the topic-x finder line.
-    expect(selection.keptAll).toBe(false);
-    expect(selection.pages).toEqual([{ slug: "topic-x", sections: [] }]);
-  });
-});

package/src/plugins/defaults/memory/worker.ts

@@ -16,10 +16,6 @@ import { getConfig } from "../../../config/loader.js";
 import { isMemoryEnabled } from "../../../config/memory-v3-gate.js";
 import { rehydratePlatformCredentials } from "../../../config/platform-rehydration.js";
 import { startConversationEvictor } from "../../../daemon/conversation-evictor.js";
-import {
-  startWorkspaceSkillMdMtimePoll,
-  stopWorkspaceSkillMdMtimePoll,
-} from "../../../daemon/skill-memory-refresh.js";
 import { resetDb } from "../../../persistence/db-connection.js";
 import {
   EMBEDDING_SHUTDOWN_BUDGET_MS,
@@ -112,7 +108,6 @@ async function main(): Promise<void> {
     shuttingDown = true;
     log.info({ signal }, "Memory worker process shutting down");
     worker?.stop();
-    stopWorkspaceSkillMdMtimePoll();
     if (keepAlive != null) {
       clearInterval(keepAlive);
     }
@@ -166,7 +161,6 @@ async function main(): Promise<void> {
   }
 
   worker = startMemoryJobsWorkerLoop();
-  startWorkspaceSkillMdMtimePoll();
 
   // Keep-alive: the worker's setTimeout timers are unref'd, so without
   // this interval the process would exit immediately.

package/src/plugins/mcp-servers.ts

@@ -14,7 +14,7 @@
  * This module reads those files and projects each entry onto the
  * assistant's own `McpServerConfig` shape, so a plugin-declared server can
  * flow through the same surfaces as one configured in the workspace
- * `mcp.json`.
+ * `config.json`.
  *
  * Failure isolation follows the spec: an invalid top-level `mcp.json`
  * disables MCP for that plugin only, and an invalid individual server
@@ -39,17 +39,17 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { z } from "zod";
+
 import {
   type AllPluginInfo,
   listAllPlugins,
   type ListInstalledPluginsOptions,
 } from "../cli/lib/list-installed-plugins.js";
-import type { ResolvedMcpServerConfig } from "../config/schemas/mcp.js";
-import {
-  projectSpecServerToTransport,
-  SpecMcpDocumentSchema,
-  SpecMcpServerSchema,
-} from "../mcp/spec-schema.js";
+import type {
+  McpTransport,
+  ResolvedMcpServerConfig,
+} from "../config/schemas/mcp.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("plugin-mcp-servers");
@@ -77,6 +77,45 @@ export const PLUGIN_MCP_MANIFEST = "mcp.json";
  * origin risk.
  */
 
+// ---------------------------------------------------------------------------
+// Wire schema (Agent Plugins 1.0.0)
+// ---------------------------------------------------------------------------
+
+const PluginStdioServerSchema = z.object({
+  type: z.literal("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional(),
+});
+
+/**
+ * Remote MCP entry. Agent Plugins 1.0.0 requires `type` and names no
+ * default. MCP's current remote transport is Streamable HTTP, so this
+ * host fills omitted `type` and the Claude-style `http` alias as
+ * `streamable-http`. `sse` stays explicit.
+ */
+const PluginHttpServerSchema = z.object({
+  type: z
+    .union([
+      z.literal("streamable-http"),
+      z.literal("sse"),
+      z.literal("http").transform(() => "streamable-http" as const),
+    ])
+    .default("streamable-http"),
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
+const PluginMcpServerSchema = z.union([
+  PluginStdioServerSchema,
+  PluginHttpServerSchema,
+]);
+
+const PluginMcpManifestSchema = z.object({
+  mcpServers: z.record(z.string(), z.unknown()),
+});
+
 // ---------------------------------------------------------------------------
 // Public shape
 // ---------------------------------------------------------------------------
@@ -212,7 +251,7 @@ export function readPluginMcpServers(
         continue;
       }
 
-      const entry = SpecMcpServerSchema.safeParse(raw);
+      const entry = PluginMcpServerSchema.safeParse(raw);
       if (!entry.success) {
         issues.push({
           pluginName: plugin.name,
@@ -286,7 +325,7 @@ function parseManifest(
     };
   }
 
-  const manifest = SpecMcpDocumentSchema.safeParse(json);
+  const manifest = PluginMcpManifestSchema.safeParse(json);
   if (!manifest.success) {
     return {
       error: `${PLUGIN_MCP_MANIFEST} is missing a valid "mcpServers" object`,
@@ -295,12 +334,33 @@ function parseManifest(
   return { mcpServers: manifest.data.mcpServers };
 }
 
+/**
+ * Project one spec-shaped entry onto the assistant's transport union. The
+ * two vocabularies already agree on type names and required fields, so this
+ * is a field copy plus path interpolation for the stdio case.
+ */
 function projectTransport(
-  entry: Parameters<typeof projectSpecServerToTransport>[0],
+  entry: z.infer<typeof PluginMcpServerSchema>,
   pluginRoot: string,
-) {
-  const pluginData = join(pluginRoot, "data");
-  return projectSpecServerToTransport(entry, (value) =>
-    interpolatePluginPaths(value, pluginRoot, pluginData),
-  );
+): McpTransport {
+  if (entry.type === "stdio") {
+    const pluginData = join(pluginRoot, "data");
+    const expand = (v: string): string =>
+      interpolatePluginPaths(v, pluginRoot, pluginData);
+    return {
+      type: "stdio",
+      command: entry.command,
+      args: (entry.args ?? []).map(expand),
+      ...(entry.env && {
+        env: Object.fromEntries(
+          Object.entries(entry.env).map(([k, v]) => [k, expand(v)]),
+        ),
+      }),
+    };
+  }
+  return {
+    type: entry.type,
+    url: entry.url,
+    ...(entry.headers && { headers: entry.headers }),
+  };
 }

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

@@ -50,8 +50,6 @@ describe("isConnectionCompatibleWithModel", () => {
     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);
-    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4")).toBe(false);
-    expect(isConnectionCompatibleWithModel(conn, "gpt-5.4-mini")).toBe(false);
   });
 
   test("oauth_subscription connection is compatible with a Codex model", () => {
@@ -61,6 +59,8 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-terra")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-luna")).toBe(true);
     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);
   });
 
   test("undefined model applies no gating (compatible)", () => {
@@ -165,7 +165,7 @@ describe("auto-resolution skips oauth_subscription connections for non-Codex mod
 
   test("Codex model can select the oauth_subscription connection", async () => {
     registerConnections([OPENAI_CODEX, OPENAI_KEY]);
-    setOpenAiProfile("gpt-5.5");
+    setOpenAiProfile("gpt-5.4");
 
     const result = await getConfiguredProvider("mainAgent", {
       overrideProfile: "openai-any",

package/src/providers/gemini/client.ts

@@ -15,7 +15,6 @@ import {
   keepFileAsWorkspaceRef,
 } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
-import { unsignedThoughtSignatureFallback } from "../gemini-thought-signature.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
@@ -46,6 +45,13 @@ import {
 const GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS =
   /token.?count.*exceeds|exceeds.*maximum.*tokens|prompt.?is.?too.?long|too.?many.?(?:input.?)?tokens|input.?too.?long|context.?length.?exceeded/i;
 
+const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
+  "context_engineering_is_the_way_to_go";
+
+function isGemini3Model(model: string): boolean {
+  return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
+}
+
 const THINKING_LEVEL_BY_NAME: Record<ThinkingLevelName, ThinkingLevel> = {
   minimal: ThinkingLevel.MINIMAL,
   low: ThinkingLevel.LOW,
@@ -429,8 +435,7 @@ export class GeminiProvider implements Provider {
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     const activeModel = modelOverride ?? this.model;
     const thinkingConfig = geminiModelSupportsThinking(activeModel)
       ? buildThinkingConfig(
@@ -897,19 +902,28 @@ export class GeminiProvider implements Provider {
     parts: genai.Part[],
     model: string,
   ): void {
+    if (!isGemini3Model(model)) {
+      return;
+    }
+
     const functionCallParts = parts.filter((part) => part.functionCall);
-    const fallback = unsignedThoughtSignatureFallback(
-      functionCallParts.map((part) => part.thoughtSignature),
-      { model },
+    if (functionCallParts.length === 0) {
+      return;
+    }
+
+    const hasRealThoughtSignature = functionCallParts.some((part) =>
+      Boolean(part.thoughtSignature),
     );
-    if (!fallback) {
+    if (hasRealThoughtSignature) {
       return;
     }
-    const firstFunctionCallPart = functionCallParts[fallback.index];
+
+    const firstFunctionCallPart = functionCallParts[0];
     if (!firstFunctionCallPart) {
       return;
     }
-    firstFunctionCallPart.thoughtSignature = fallback.signature;
+    firstFunctionCallPart.thoughtSignature =
+      GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
   }
 
   private supportsGeminiInlineFile(mimeType: string): boolean {

package/src/providers/model-catalog.ts

@@ -76,13 +76,6 @@ export interface CatalogModel {
   supportsAudioInput?: boolean;
   supportsToolUse?: boolean;
   supportsEffort?: boolean;
-  /**
-   * Whether this provider/model serving surface accepts a forced OpenAI
-   * chat-completions tool choice while thinking is enabled. Omit unless the
-   * combination is known incompatible. Daemon-only: not projected into the
-   * client catalog (see scripts/sync-llm-catalog.ts).
-   */
-  supportsForcedToolChoiceWithThinking?: boolean;
   pricing?: CatalogModelPricing;
   /**
    * Upper bound for `reasoning_effort` accepted by this model's upstream API.
@@ -863,9 +856,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.03,
         },
       },
-      // Limited to grandfathered accounts: other API keys get HTTP 404 "no
-      // longer available to new users", so this model is user-selectable
-      // only and no intent column may resolve to it.
       {
         id: "gemini-2.5-flash-lite",
         displayName: "Gemini 2.5 Flash Lite",
@@ -1826,7 +1816,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsCaching: true,
         supportsVision: true,
         supportsToolUse: true,
-        supportsForcedToolChoiceWithThinking: false,
         pricing: {
           inputPer1mTokens: 0.95,
           outputPer1mTokens: 4.0,
@@ -2639,29 +2628,6 @@ export function modelSupportedEfforts(
   );
 }
 
-/**
- * Whether a provider/model serving surface accepts a forced OpenAI
- * chat-completions tool choice while thinking is enabled. Unknown providers
- * and models fail open so custom routes retain their existing request shape
- * and can rely on the bounded provider-error retry if needed.
- */
-export function supportsForcedToolChoiceWithThinking(
-  providerId: string,
-  modelId: string,
-): boolean {
-  const provider = PROVIDER_CATALOG.find((entry) => entry.id === providerId);
-  if (!provider) {
-    return true;
-  }
-  const stripDateSuffix = (id: string): string => id.replace(/-\d{8}$/, "");
-  const normalizedModelId = stripDateSuffix(modelId);
-  return !provider.models.some(
-    (model) =>
-      model.supportsForcedToolChoiceWithThinking === false &&
-      (model.id === modelId || stripDateSuffix(model.id) === normalizedModelId),
-  );
-}
-
 /**
  * Return the catalog provider that owns a model ID, if known. When multiple
  * providers list the same ID (e.g. OpenRouter and the Vercel AI Gateway share

package/src/providers/model-intents.ts

@@ -11,15 +11,10 @@ const PROVIDER_DEFAULT_MODELS: Record<string, string> = Object.fromEntries(
 );
 
 // `cost-optimized` is the cheapest model a provider serves, `latency-optimized`
-// the fastest to first token. On anthropic, ollama, fireworks, openai and
-// gemini the same model is both, so those columns repeat by construction
-// rather than by oversight (openai's balanced repeats it too: the
-// default-profile templates split those tiers by reasoning effort, not model).
-//
-// "Serves" means serves to every API key: Google's `gemini-2.5-flash-lite`
-// undercuts every 3.x Flash-Lite but is limited to grandfathered accounts
-// (other keys get HTTP 404 "no longer available to new users"), so the
-// gemini column skips it.
+// the fastest to first token. On anthropic, ollama, fireworks and openai the
+// same model is both, so those columns repeat by construction rather than by
+// oversight (openai's balanced repeats it too: the default-profile templates
+// split those tiers by reasoning effort, not model).
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
@@ -37,7 +32,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "cost-optimized": "gemini-3.1-flash-lite",
+    "cost-optimized": "gemini-2.5-flash-lite",
     "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -934,55 +934,6 @@ describe("thinking-mode tool_choice rejection fallback", () => {
     expect(text?.text).toBe("ok");
   });
 
-  test("retries once when Kimi rejects a specified tool_choice in thinking mode", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "tool_choice 'specified' is incompatible with thinking enabled",
-        ),
-      ],
-      OK_CHUNKS,
-    );
-
-    const response = await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-      {
-        tools: [
-          {
-            name: "select_pages",
-            description: "Pick relevant memory pages",
-            input_schema: { type: "object", properties: {} },
-          },
-        ],
-        config: {
-          tool_choice: { type: "tool", name: "select_pages" },
-          effort: "high",
-        },
-      },
-    );
-
-    expect(requests).toHaveLength(2);
-    const first = requests[0] as {
-      tool_choice?: { type: string; function: { name: string } };
-      reasoning_effort?: string;
-    };
-    const second = requests[1] as {
-      tool_choice?: unknown;
-      reasoning_effort?: string;
-    };
-    expect(first.tool_choice).toEqual({
-      type: "function",
-      function: { name: "select_pages" },
-    });
-    expect(first.reasoning_effort).toBe("high");
-    expect(second.tool_choice).toBeUndefined();
-    expect(second.reasoning_effort).toBe("high");
-    const text = response.content.find((b) => b.type === "text") as
-      | { type: "text"; text: string }
-      | undefined;
-    expect(text?.text).toBe("ok");
-  });
-
   test("retries once for an OpenRouter-wrapped thinking-mode tool_choice rejection", async () => {
     const wrapped = new OpenAI.APIError(
       400,
@@ -1190,80 +1141,33 @@ describe("unknown assistant reasoning field rejection fallback", () => {
     },
   ];
 
-  test.each([
-    [
-      "a strict schema",
-      "Additional properties are not allowed ('reasoning_content' was unexpected)",
-    ],
-    ["Groq", "property 'reasoning_content' is unsupported"],
-  ])(
-    "retries once without reasoning_content when %s rejects it",
-    async (_upstream, message) => {
-      const { provider, requests } = stubProviderWithErrors(
-        [rejection(message)],
-        OK_CHUNKS,
-        { assistantReasoningField: "reasoning_content" },
-      );
-
-      const response = await provider.sendMessage(thinkingHistory);
-
-      expect(requests).toHaveLength(2);
-      const first = requests[0] as {
-        messages: Array<{ reasoning_content?: string; content: string | null }>;
-      };
-      const second = requests[1] as {
-        messages: Array<{ reasoning_content?: string; content: string | null }>;
-      };
-      expect(first.messages[0].reasoning_content).toBe("hidden chain");
-      expect(second.messages[0].reasoning_content).toBeUndefined();
-      expect(second.messages[0].content).toBe("answer");
-      const text = response.content.find((b) => b.type === "text") as
-        | { type: "text"; text: string }
-        | undefined;
-      expect(text?.text).toBe("ok");
-    },
-  );
-
-  test("preserves assistant tool calls when stripping an unsupported reasoning_content", async () => {
+  test("retries once without reasoning_content when a strict schema rejects it", async () => {
     const { provider, requests } = stubProviderWithErrors(
-      [rejection("property 'reasoning_content' is unsupported")],
+      [
+        rejection(
+          "Additional properties are not allowed ('reasoning_content' was unexpected)",
+        ),
+      ],
       OK_CHUNKS,
       { assistantReasoningField: "reasoning_content" },
     );
 
-    await provider.sendMessage([
-      {
-        role: "assistant",
-        content: [
-          { type: "thinking", thinking: "hidden chain", signature: "" },
-          {
-            type: "tool_use",
-            id: "call_1",
-            name: "lookup",
-            input: { q: "x" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "call_1", content: "found" },
-        ],
-      },
-    ]);
+    const response = await provider.sendMessage(thinkingHistory);
 
     expect(requests).toHaveLength(2);
+    const first = requests[0] as {
+      messages: Array<{ reasoning_content?: string; content: string | null }>;
+    };
     const second = requests[1] as {
-      messages: Array<{
-        role: string;
-        reasoning_content?: string;
-        tool_calls?: Array<{ id: string; function: { name: string } }>;
-      }>;
+      messages: Array<{ reasoning_content?: string; content: string | null }>;
     };
-    const assistant = second.messages.find((m) => m.role === "assistant");
-    expect(assistant?.reasoning_content).toBeUndefined();
-    expect(assistant?.tool_calls?.[0]?.id).toBe("call_1");
-    expect(assistant?.tool_calls?.[0]?.function.name).toBe("lookup");
+    expect(first.messages[0].reasoning_content).toBe("hidden chain");
+    expect(second.messages[0].reasoning_content).toBeUndefined();
+    expect(second.messages[0].content).toBe("answer");
+    const text = response.content.find((b) => b.type === "text") as
+      | { type: "text"; text: string }
+      | undefined;
+    expect(text?.text).toBe("ok");
   });
 
   test("does not strip reasoning_content on a must-be-passed-back error", async () => {
@@ -1285,38 +1189,6 @@ describe("unknown assistant reasoning field rejection fallback", () => {
     ).toBe("hidden chain");
   });
 
-  test("does not strip reasoning_content on a 429 output-token limit", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "Rate limit reached for model `qwen/qwen3-32b` in organization `org_x` on tokens per minute (TPM): Limit 1000, Requested 4000.",
-          429,
-        ),
-      ],
-      OK_CHUNKS,
-      { assistantReasoningField: "reasoning_content" },
-    );
-
-    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
-    expect(requests).toHaveLength(1);
-  });
-
-  test("does not strip reasoning_content on a 413 input-token limit", async () => {
-    const { provider, requests } = stubProviderWithErrors(
-      [
-        rejection(
-          "Request too large for model `qwen/qwen3-32b` in organization `org_x` on tokens per minute (TPM): Limit 7000, Requested 24936.",
-          413,
-        ),
-      ],
-      OK_CHUNKS,
-      { assistantReasoningField: "reasoning_content" },
-    );
-
-    await expect(provider.sendMessage(thinkingHistory)).rejects.toThrow();
-    expect(requests).toHaveLength(1);
-  });
-
   test("does not retry unknown-field 500s", async () => {
     const { provider, requests } = stubProviderWithErrors(
       [