@vellumai/assistant 0.8.2 → 0.8.3

package/src/__tests__/openai-provider.test.ts

@@ -21,6 +21,13 @@ interface FakeChunk {
   choices: Array<{
     delta: {
       content?: string | null;
+      reasoning_content?: string | null;
+      reasoning?: string | null;
+      reasoning_details?: Array<{
+        type?: string;
+        summary?: string | null;
+        text?: string | null;
+      }> | null;
       tool_calls?: Array<{
         index: number;
         id?: string;
@@ -209,6 +216,44 @@ function cachedUsageChunk(
   };
 }
 
+function reasoningChunk(
+  reasoning: string,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [
+      { delta: { reasoning_content: reasoning }, finish_reason: finish },
+    ],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
+// OpenRouter spec uses `delta.reasoning` rather than `delta.reasoning_content`.
+function openRouterReasoningChunk(
+  reasoning: string,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [{ delta: { reasoning }, finish_reason: finish }],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
+// OpenRouter's documented reasoning-summary shape: a `reasoning_details` array
+// with entries tagged `reasoning.summary` / `reasoning.text` / `reasoning.encrypted`.
+function reasoningDetailsChunk(
+  details: Array<{ type?: string; summary?: string; text?: string }>,
+  finish: string | null = null,
+): FakeChunk {
+  return {
+    choices: [{ delta: { reasoning_details: details }, finish_reason: finish }],
+    usage: null,
+    model: "gpt-5.2",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Class extraction sanity checks
 // ---------------------------------------------------------------------------
@@ -339,6 +384,153 @@ describe("OpenAIProvider", () => {
     expect(events[1]).toEqual({ type: "text_delta", text: ", world!" });
   });
 
+  // -----------------------------------------------------------------------
+  // Reasoning content (MiniMax / DeepSeek extension)
+  // -----------------------------------------------------------------------
+  test("parses reasoning_content into thinking block", async () => {
+    fakeChunks = [
+      reasoningChunk("Let me think..."),
+      textChunk("The answer is 42."),
+      usageChunk(10, 20),
+    ];
+
+    const result = await provider.sendMessage([userMsg("Hi")]);
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Let me think...",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({
+      type: "text",
+      text: "The answer is 42.",
+    });
+    expect(result.usage).toEqual({ inputTokens: 10, outputTokens: 20 });
+  });
+
+  test("fires thinking_delta events during streaming", async () => {
+    fakeChunks = [
+      reasoningChunk("Let me think..."),
+      textChunk("The answer is 42."),
+      usageChunk(10, 20),
+    ];
+
+    const events: ProviderEvent[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (e) => events.push(e),
+    });
+
+    expect(events).toHaveLength(2);
+    expect(events[0]).toEqual({
+      type: "thinking_delta",
+      thinking: "Let me think...",
+    });
+    expect(events[1]).toEqual({
+      type: "text_delta",
+      text: "The answer is 42.",
+    });
+  });
+
+  test("reasoning + tool calls orders correctly (thinking → tool_use)", async () => {
+    fakeChunks = [
+      reasoningChunk("Planning..."),
+      ...toolCallChunks([
+        { id: "call_1", name: "file_read", args: '{"path":"/a"}' },
+      ]),
+      usageChunk(10, 30),
+    ];
+
+    const result = await provider.sendMessage([userMsg("Read /a")]);
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe("thinking");
+    expect(result.content[1].type).toBe("tool_use");
+  });
+
+  test("no thinking block when reasoning_content is absent", async () => {
+    fakeChunks = [textChunk("Just text"), usageChunk(10, 5)];
+
+    const result = await provider.sendMessage([userMsg("Hi")]);
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+  });
+
+  test("parses OpenRouter's `delta.reasoning` field into thinking block", async () => {
+    fakeChunks = [
+      openRouterReasoningChunk("Hmm, let me think..."),
+      textChunk("Final answer."),
+      usageChunk(10, 8),
+    ];
+
+    const events: ProviderEvent[] = [];
+    const result = await provider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      undefined,
+      {
+        onEvent: (e) => events.push(e),
+      },
+    );
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Hmm, let me think...",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({ type: "text", text: "Final answer." });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Hmm, let me think...",
+    });
+  });
+
+  test("parses OpenRouter `delta.reasoning_details` summary/text entries and skips encrypted", async () => {
+    fakeChunks = [
+      reasoningDetailsChunk([
+        { type: "reasoning.summary", summary: "Plan step one. " },
+        { type: "reasoning.encrypted", text: "ENCRYPTED_BLOB" },
+        { type: "reasoning.text", text: "Detailed thought." },
+      ]),
+      textChunk("Done."),
+      usageChunk(10, 8),
+    ];
+
+    const events: ProviderEvent[] = [];
+    const result = await provider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      undefined,
+      {
+        onEvent: (e) => events.push(e),
+      },
+    );
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0]).toEqual({
+      type: "thinking",
+      thinking: "Plan step one. Detailed thought.",
+      signature: "",
+    });
+    expect(result.content[1]).toEqual({ type: "text", text: "Done." });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Plan step one. ",
+    });
+    expect(events).toContainEqual({
+      type: "thinking_delta",
+      thinking: "Detailed thought.",
+    });
+    // Encrypted blob must never surface as visible thinking.
+    for (const e of events) {
+      if (e.type === "thinking_delta") {
+        expect(e.thinking).not.toContain("ENCRYPTED_BLOB");
+      }
+    }
+  });
+
   // -----------------------------------------------------------------------
   // System prompt
   // -----------------------------------------------------------------------
@@ -1306,14 +1498,17 @@ describe("OpenRouterProvider reasoning", () => {
     shouldThrow = null;
   });
 
-  test("sends reasoning.enabled=true when thinking config is present", async () => {
+  test("sends reasoning.enabled=true with default detailed summary when thinking config is present", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "adaptive" } },
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      summary: "detailed",
+    });
   });
 
   test("sends reasoning.enabled=false when thinking is explicitly disabled", async () => {
@@ -1376,7 +1571,10 @@ describe("OpenRouterProvider reasoning", () => {
     await retry.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "adaptive" } },
     });
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: true });
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      summary: "detailed",
+    });
   });
 
   test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
@@ -1389,6 +1587,23 @@ describe("OpenRouterProvider reasoning", () => {
     });
     expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
   });
+
+  test("nests effort under reasoning and omits top-level reasoning_effort", async () => {
+    const provider = new OpenRouterProvider("or-key", "moonshotai/kimi-k2.6");
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: { thinking: { enabled: true }, effort: "max" },
+    });
+
+    expect(lastCreateParams).toBeTruthy();
+    expect(lastCreateParams!.reasoning).toEqual({
+      enabled: true,
+      effort: "xhigh",
+      summary: "detailed",
+    });
+    // Critical: must NOT also send the OpenAI-native flat field — OpenRouter
+    // rejects requests that carry both forms for reasoning models.
+    expect(lastCreateParams).not.toHaveProperty("reasoning_effort");
+  });
 });
 
 describe("OpenRouterProvider Anthropic-compatible errors", () => {

package/src/__tests__/openai-responses-cutover-guard.test.ts

@@ -92,9 +92,9 @@ describe("OpenAI Responses API cutover guard", () => {
 
     // The factory must NOT instantiate OpenAIChatCompletionsProvider or
     // OpenAIProvider (the backward-compatible alias) inside the `openai:`
-    // factory entry. Other entries (e.g. `zai:`, `deepseek:`, `minimax:`)
-    // may legitimately use OpenAIChatCompletionsProvider since that's the
-    // OpenAI Chat Completions transport for third-party endpoints.
+    // factory entry. Other entries (e.g. `openai-compatible:`) may legitimately
+    // use OpenAIChatCompletionsProvider since that's the OpenAI Chat Completions
+    // transport for third-party endpoints.
     const openaiEntryRegion =
       /(?:^|\s)openai\s*:\s*\([^)]*\)\s*=>\s*[\s\S]{0,400}?(?=\}\s*,\s*[a-z-]+\s*:|\}\s*;)/m.exec(
         source,

package/src/__tests__/openrouter-provider-only.test.ts

@@ -116,7 +116,7 @@ describe("OpenRouter provider.only plumbing", () => {
       expect(extras.provider).toBe(undefined);
     });
 
-    test("still carries reasoning flag alongside provider.only", () => {
+    test("enables thinking with default detailed summary alongside provider.only", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -128,12 +128,12 @@ describe("OpenRouter provider.only plumbing", () => {
         },
       });
       expect(extras).toEqual({
-        reasoning: { enabled: true },
+        reasoning: { enabled: true, summary: "detailed" },
         provider: { only: ["xAI"] },
       });
     });
 
-    test("disabled thinking keeps reasoning disabled alongside provider.only", () => {
+    test("disabled thinking keeps reasoning disabled and omits summary", () => {
       const provider = new ProbeOpenRouterProvider(
         "fake-key",
         "x-ai/grok-4.20-beta",
@@ -149,5 +149,53 @@ describe("OpenRouter provider.only plumbing", () => {
         provider: { only: ["xAI"] },
       });
     });
+
+    test("nests effort under reasoning and maps `max` to xhigh", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          effort: "max",
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, effort: "xhigh", summary: "detailed" },
+      });
+    });
+
+    test("honors a per-call summary override", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "concise" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "concise" },
+      });
+    });
+
+    test("ignores an invalid summary override and falls back to detailed", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "moonshotai/kimi-k2.6",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { enabled: true },
+          openrouter: { reasoning: { summary: "verbose" } },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: true, summary: "detailed" },
+      });
+    });
   });
 });

package/src/__tests__/openrouter-token-estimation.test.ts

@@ -5,7 +5,11 @@ import { OpenRouterProvider } from "../providers/openrouter/client.js";
 import type { Message } from "../providers/types.js";
 
 /** Build a minimal valid PNG header encoding the given dimensions. */
-function makePngBase64(width: number, height: number, paddingBytes = 0): string {
+function makePngBase64(
+  width: number,
+  height: number,
+  paddingBytes = 0,
+): string {
   const header = Buffer.alloc(24);
   header[0] = 0x89;
   header[1] = 0x50;
@@ -41,13 +45,13 @@ describe("OpenRouterProvider token estimation routing", () => {
     expect(provider.tokenEstimationProvider).toBe("openrouter");
   });
 
-  test("estimatePromptTokens applies Anthropic image scaling when routed via OpenRouter", () => {
+  test("estimatePromptTokens applies dimension-based image scaling when routed via OpenRouter to Anthropic", () => {
     const provider = new OpenRouterProvider(
       "fake-key",
       "anthropic/claude-opus-4-6",
     );
     // 1920x1080 screenshot with ~200 KB of pixel data → base64/4 would be ~65k
-    // tokens; dimension-based Anthropic rules land around 1.6k tokens.
+    // tokens; dimension-based rules land around 1.6k tokens.
     const messages: Message[] = [
       {
         role: "user",
@@ -68,33 +72,38 @@ describe("OpenRouterProvider token estimation routing", () => {
       providerName: provider.tokenEstimationProvider,
     });
 
-    // Dimension-based estimate should be well under 5k; base64/4 would exceed 50k.
     expect(estimated).toBeLessThan(5_000);
   });
 
-  test("estimatePromptTokens falls back to base64/4 for non-Anthropic OpenRouter models", () => {
-    const provider = new OpenRouterProvider("fake-key", "x-ai/grok-4.20-beta");
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: "image/png",
-              data: makePngBase64(1920, 1080, 200_000),
+  test("estimatePromptTokens applies dimension-based image scaling for non-Anthropic OpenRouter models", () => {
+    // A naive base64/4 estimate on a 1920x1080 screenshot (~200 KB) lands near
+    // 65k tokens and trips spurious compaction long before the real context
+    // window fills. Vision models on OpenRouter — both anthropic/* and
+    // non-Anthropic (Kimi K2.6, Grok, etc.) — must use the dimension-based
+    // formula.
+    for (const model of ["moonshotai/kimi-k2.6", "x-ai/grok-4.20-beta"]) {
+      const provider = new OpenRouterProvider("fake-key", model);
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/png",
+                data: makePngBase64(1920, 1080, 200_000),
+              },
             },
-          },
-        ],
-      },
-    ];
+          ],
+        },
+      ];
 
-    const estimated = estimatePromptTokens(messages, "system", {
-      providerName: provider.tokenEstimationProvider,
-    });
+      const estimated = estimatePromptTokens(messages, "system", {
+        providerName: provider.tokenEstimationProvider,
+      });
 
-    // Base64/4 heuristic on ~200 KB of image data → far more than 10k tokens.
-    expect(estimated).toBeGreaterThan(50_000);
+      expect(estimated).toBeLessThan(5_000);
+    }
   });
 });

package/src/__tests__/platform-proxy-context.test.ts

@@ -117,8 +117,13 @@ describe("buildManagedBaseUrl", () => {
     );
   });
 
+  test("returns managed URL for fireworks", async () => {
+    expect(await buildManagedBaseUrl("fireworks")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/fireworks",
+    );
+  });
+
   test("returns undefined for non-managed providers", async () => {
-    expect(await buildManagedBaseUrl("fireworks")).toBeUndefined();
     expect(await buildManagedBaseUrl("openrouter")).toBeUndefined();
     expect(await buildManagedBaseUrl("ollama")).toBeUndefined();
   });

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -59,7 +59,7 @@ import {
   unregisterPluginTools,
 } from "../tools/registry.js";
 import type {
-  PluginTool,
+  LoadedPluginTool,
   ToolContext,
   ToolExecutionResult,
 } from "../tools/types.js";
@@ -81,8 +81,8 @@ const fakeCtx: DaemonContext = {
 
 function makeFakeTool(
   name: string,
-  extras: Partial<PluginTool> = {},
-): PluginTool {
+  extras: Partial<LoadedPluginTool> = {},
+): LoadedPluginTool {
   return {
     name,
     description: `Fake ${name}`,

package/src/__tests__/plugin-types.test.ts

@@ -46,7 +46,7 @@ import {
   type ToolResultTruncateResult,
   type TurnContext,
 } from "../plugins/types.js";
-import type { PluginTool } from "../tools/types.js";
+import type { LoadedPluginTool } from "../tools/types.js";
 
 const sampleTrust: TrustContext = {
   sourceChannel: "vellum",
@@ -207,7 +207,7 @@ describe("plugin core types", () => {
       },
     };
 
-    const sampleTool: PluginTool = {
+    const sampleTool: LoadedPluginTool = {
       name: "sample-tool",
       description: "Sample plugin tool",
       defaultRiskLevel: RiskLevel.Low,

package/src/__tests__/provider-catalog-visibility.test.ts

@@ -19,6 +19,22 @@ function makeConfig(): AssistantConfig {
 }
 
 describe("getVisibleProviderCatalog", () => {
+  test("hides openai-compatible endpoints by default", () => {
+    _setOverridesForTesting({});
+
+    const visible = getVisibleProviderCatalog(makeConfig());
+
+    expect(visible.find((p) => p.id === "openai-compatible")).toBeUndefined();
+  });
+
+  test("shows openai-compatible endpoints when its flag is enabled", () => {
+    _setOverridesForTesting({ "openai-compatible-endpoints": true });
+
+    const visible = getVisibleProviderCatalog(makeConfig());
+
+    expect(visible.find((p) => p.id === "openai-compatible")).toBeDefined();
+  });
+
   test("returns the full catalog when all feature flags are enabled", () => {
     const allFlags: Record<string, boolean> = {};
     for (const entry of PROVIDER_CATALOG) {

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -113,7 +113,7 @@ const DIRECT_OR_MANAGED_PROVIDER_KEYS: string[] = [
   "fireworks",
   "openrouter",
 ];
-const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini", "openai"];
+const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini", "openai", "fireworks"];
 
 function enableManagedProxy() {
   mockPlatformBaseUrl = PLATFORM_BASE;
@@ -209,20 +209,19 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, and gemini", async () => {
+    test("managed bootstrap registers anthropic, openai, gemini, and fireworks", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual(
-        expect.arrayContaining(["anthropic", "openai", "gemini"]),
+        expect.arrayContaining(["anthropic", "openai", "gemini", "fireworks"]),
       );
-      expect(listProviders()).toHaveLength(3);
+      expect(listProviders()).toHaveLength(4);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
     test("managed anthropic uses anthropic proxy path", async () => {
@@ -376,7 +375,7 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("mixed: some user keys + managed fallback fills gaps", () => {
-    test("user key for anthropic routes direct and managed fallback fills openai and gemini", async () => {
+    test("user key for anthropic routes direct and managed fallback fills openai, gemini, and fireworks", async () => {
       enableManagedProxy();
       setUserKeysFor("anthropic");
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
@@ -387,13 +386,13 @@ describe("managed proxy integration — credential precedence", () => {
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(registered).not.toContain(p);
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(registered).toContain("fireworks");
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(registered).not.toContain("openrouter");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
-    test("user key for openai routes direct while anthropic and gemini still bootstrap via managed proxy", async () => {
+    test("user key for openai routes direct while anthropic, gemini, and fireworks still bootstrap via managed proxy", async () => {
       enableManagedProxy();
       setUserKeysFor("openai");
       await initializeProviders(makeProvidersConfig("openai", "test-model"));
@@ -404,11 +403,10 @@ describe("managed proxy integration — credential precedence", () => {
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      // OpenAI has a user key so it's user-key, not managed-proxy
-      for (const p of ["fireworks", "openrouter"]) {
-        expect(registered).not.toContain(p);
-        expect(getProviderRoutingSource(p)).toBeUndefined();
-      }
+      expect(registered).toContain("fireworks");
+      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(registered).not.toContain("openrouter");
+      expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
   });
 });
@@ -476,8 +474,8 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "openai", "gemini"]) {
+  test("anthropic, openai, gemini, and fireworks have metadata with managed=true and a proxyPath", () => {
+    for (const provider of ["anthropic", "openai", "gemini", "fireworks"]) {
       const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -504,10 +502,14 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
-  test("fireworks and openrouter are not managed proxy capable", () => {
-    for (const provider of ["fireworks", "openrouter"]) {
-      expect(PLATFORM_PROVIDER_META[provider].managed).toBe(false);
-      expect(PLATFORM_PROVIDER_META[provider].proxyPath).toBeUndefined();
-    }
+  test("fireworks routes through fireworks proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.fireworks.proxyPath).toBe(
+      "/v1/runtime-proxy/fireworks",
+    );
+  });
+
+  test("openrouter is not managed proxy capable", () => {
+    expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
+    expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();
   });
 });

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -12,7 +12,7 @@ let providerRefreshCalls = 0;
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
 const PLATFORM_BASE_URL_PATH = credentialKey("vellum", "platform_base_url");
-const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini"] as const;
+const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini", "fireworks"] as const;
 
 let platformBaseUrlOverride: string | undefined;