@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/plugin-source-watcher.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Tests for PluginSourceWatcher — filesystem watcher that detects plugin
+ * directory changes and triggers debounced reregistration.
+ *
+ * Key regression: the watcher must survive (and recover from) the Linux/Bun
+ * recursive-watch limitation where subdirectories created after watch starts
+ * are silently dropped. We test that close→reopen + rescan catches these.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+const TEST_PLUGINS_DIR = "/tmp/test-plugins";
+
+let capturedWatchCallback:
+  | ((eventType: string, filename: string | null) => void)
+  | null = null;
+let mockWatchShouldThrow = false;
+const mockWatcher = { close: mock(() => {}) };
+
+const mockWatch = mock(
+  (
+    _path: string,
+    _opts: Record<string, unknown>,
+    callback: (eventType: string, filename: string | null) => void,
+  ) => {
+    if (mockWatchShouldThrow) throw new Error("watch failed");
+    capturedWatchCallback = callback;
+    return mockWatcher;
+  },
+);
+
+const mockRereadirSync = mock((_path: string): string[] => []);
+
+let mockGetRegisteredPluginImpl: (name: string) => unknown | undefined = (
+  _name,
+) => undefined;
+const mockGetRegisteredPlugin = mock((name: string) =>
+  mockGetRegisteredPluginImpl(name),
+);
+
+let mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+const mockReregisterExternalPlugin = mock(async (name: string) =>
+  mockReregisterExternalPluginImpl(name),
+);
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actualFs = require("node:fs");
+  return {
+    ...actualFs,
+    watch: mockWatch,
+    readdirSync: mockRereadirSync,
+  };
+});
+
+mock.module("../plugins/registry.js", () => ({
+  getRegisteredPlugin: mockGetRegisteredPlugin,
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspacePluginsDir: mock(() => TEST_PLUGINS_DIR),
+}));
+
+mock.module("../daemon/external-plugins-bootstrap.js", () => ({
+  reregisterExternalPlugin: mockReregisterExternalPlugin,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: mock(() => ({
+    info: mock(() => {}),
+    warn: mock(() => {}),
+  })),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { PluginSourceWatcher } from "../daemon/plugin-source-watcher.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("PluginSourceWatcher", () => {
+  beforeEach(() => {
+    PluginSourceWatcher.resetForTests();
+    capturedWatchCallback = null;
+    mockWatchShouldThrow = false;
+    mockWatcher.close.mockClear();
+    mockWatch.mockClear();
+    mockRereadirSync.mockClear();
+    mockGetRegisteredPlugin.mockClear();
+    mockReregisterExternalPlugin.mockClear();
+    mockGetRegisteredPluginImpl = (_name: string) => undefined;
+    mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+  });
+
+  afterEach(() => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.stop();
+  });
+
+  test("start() creates a recursive watcher on the plugins directory", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("plugin directory creation triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin");
+
+    // Wait for debounce
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("nested file change within plugin triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("deeply nested file change triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/handlers/util/helper.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("dotfiles in plugins root are ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", ".DS_Store");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("null filename is ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", null);
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("rapid changes to same plugin are debounced into single rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    capturedWatchCallback!("change", "my-plugin/src/handlers.ts");
+    capturedWatchCallback!("change", "my-plugin/package.json");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(1);
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("changes to different plugins trigger separate rebuilds (debounced)", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "plugin-a/src/index.ts");
+    capturedWatchCallback!("change", "plugin-b/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(2);
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(1, "plugin-a");
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(2, "plugin-b");
+  });
+
+  test("stop() closes watcher and cancels pending rebuilds", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    watcher.stop();
+
+    expect(mockWatcher.close).toHaveBeenCalledTimes(1);
+    // No rebuild should fire after stop
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("ensureStarted() initializes watcher after start() if watch coverage was lost", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+
+    // Simulate lost coverage while the daemon lifecycle is still started
+    // (e.g. a previous watch attempt failed after startup).
+    (watcher as unknown as { watcher: unknown }).watcher = null;
+    capturedWatchCallback = null;
+
+    watcher.ensureStarted();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("ensureStarted() is a no-op when watcher is already running", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const callCountAfterStart = mockWatch.mock.calls.length;
+
+    watcher.ensureStarted();
+    expect(mockWatch.mock.calls.length).toBe(callCountAfterStart);
+  });
+
+  test("watcher restart keeps the previous watcher active if replacement fails", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const firstCallback = capturedWatchCallback;
+
+    mockWatchShouldThrow = true;
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+
+    expect(mockWatcher.close).not.toHaveBeenCalled();
+    expect((watcher as unknown as { watcher: unknown }).watcher).toBe(
+      mockWatcher,
+    );
+    expect(capturedWatchCallback).toBe(firstCallback);
+  });
+
+  test("singleton instance is shared across calls", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    const watcher2 = PluginSourceWatcher.getInstance();
+    expect(watcher1).toBe(watcher2);
+  });
+
+  test("resetForTests() clears the singleton", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    watcher1.start();
+
+    PluginSourceWatcher.resetForTests();
+    const watcher2 = PluginSourceWatcher.getInstance();
+
+    expect(watcher1).not.toBe(watcher2);
+  });
+
+  /**
+   * REGRESSION: When an event arrives during a close→reopen swap, rescan
+   * must catch any plugin not yet in the registry.
+   *
+   * Scenario:
+   * 1. Plugin "new-plugin" directory is created
+   * 2. Event fires, triggering a watcher restart (close + reopen)
+   * 3. Before the old watcher's callback is fully fired, another plugin
+   *    "late-plugin" is created
+   * 4. The new watcher doesn't yet know about "late-plugin"
+   * 5. After the reopen, rescan walks the directory and finds "late-plugin"
+   *    not in the registry, and schedules its rebuild
+   */
+  test("watcher restart + rescan catches plugins created during close→reopen", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    // Track which plugins are "registered" at each point
+    const registeredPlugins = new Set<string>();
+    mockGetRegisteredPluginImpl = (name: string) =>
+      registeredPlugins.has(name) ? { name } : undefined;
+
+    // Simulate multiple plugins on disk
+    mockRereadirSync.mockImplementation(() => [
+      "new-plugin",
+      "late-plugin",
+      ".DS_Store",
+    ]);
+
+    // Fire an event on new-plugin (this will trigger a watcher restart)
+    capturedWatchCallback!("change", "new-plugin/src/index.ts");
+
+    // Wait for the direct rebuild debounce, the watcher-restart debounce,
+    // and the rescan-triggered rebuild debounce.
+    await new Promise((r) => setTimeout(r, 1100));
+
+    // At this point, rescan should have run and discovered late-plugin,
+    // even though no direct fs.watch event was delivered for it.
+    const calls = mockReregisterExternalPlugin.mock.calls.map((c) => c[0]);
+    expect(calls).toContain("new-plugin");
+    expect(calls).toContain("late-plugin");
+    expect(calls).not.toContain(".DS_Store");
+  });
+});

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__/process-message-background-slack.test.ts

@@ -95,7 +95,6 @@ type PersistUserMessageMock = ReturnType<
 type RunAgentLoopMock = ReturnType<
   typeof mock<(...args: unknown[]) => Promise<void>>
 >;
-type NoticeMock = ReturnType<typeof mock<(notice: string | undefined) => void>>;
 interface TestConversation {
   conversationId: string;
   trustContext: unknown;
@@ -123,13 +122,10 @@ interface TestConversation {
     estimatedCost: number;
   };
   persistUserMessage: PersistUserMessageMock;
-  setSlackRuntimeContextNotice: NoticeMock;
   runAgentLoop: RunAgentLoopMock;
   updateClient: (sender: (...args: unknown[]) => void) => void;
   getCurrentSender: () => ((...args: unknown[]) => void) | undefined;
   __loopDeferred: Deferred<void>;
-  __noticeCalls: Array<string | undefined>;
-  __loopNotices: Array<string | undefined>;
   __clientSenders: Array<((...args: unknown[]) => void) | undefined>;
 }
 
@@ -171,11 +167,8 @@ async function waitForRunAgentLoopCall(): Promise<void> {
 function makeConversation(): TestConversation {
   let turnChannelContext: TurnChannelContext | null = null;
   let turnInterfaceContext: TurnInterfaceContext | null = null;
-  let slackNotice: string | undefined;
   let currentSender: ((...args: unknown[]) => void) | undefined;
-  const noticeCalls: Array<string | undefined> = [];
   const loopDeferred = createDeferred<void>();
-  const loopNotices: Array<string | undefined> = [];
   const clientSenders: Array<((...args: unknown[]) => void) | undefined> = [];
   const messages: unknown[] = [];
 
@@ -223,12 +216,7 @@ function makeConversation(): TestConversation {
         _metadata?: Record<string, unknown>,
       ) => "persisted-user-message-id",
     ),
-    setSlackRuntimeContextNotice: mock((notice: string | undefined) => {
-      slackNotice = notice;
-      noticeCalls.push(notice);
-    }),
     runAgentLoop: mock(async (..._args: unknown[]) => {
-      loopNotices.push(slackNotice);
       await loopDeferred.promise;
     }),
     updateClient: (sender: (...args: unknown[]) => void) => {
@@ -237,8 +225,6 @@ function makeConversation(): TestConversation {
     },
     getCurrentSender: () => currentSender,
     __loopDeferred: loopDeferred,
-    __noticeCalls: noticeCalls,
-    __loopNotices: loopNotices,
     __clientSenders: clientSenders,
   };
 
@@ -252,15 +238,13 @@ describe("processMessageInBackground Slack option propagation", () => {
     broadcastMessages.length = 0;
   });
 
-  test("passes Slack inbound metadata to persistence and exposes the runtime notice during the loop", async () => {
+  test("passes Slack inbound metadata to persistence during background processing", async () => {
     const slackInbound = {
       channelId: "C0123CHANNEL",
       channelTs: "1700000001.111111",
       threadTs: "1700000000.000001",
       displayName: "Alice",
     };
-    const notice =
-      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
 
     const result = await processMessageInBackground(
       "conv-background-slack",
@@ -268,7 +252,6 @@ describe("processMessageInBackground Slack option propagation", () => {
       undefined,
       {
         slackInbound,
-        slackRuntimeContextNotice: notice,
       },
       "slack",
       "slack",
@@ -280,43 +263,10 @@ describe("processMessageInBackground Slack option propagation", () => {
       slackInbound,
     });
     expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
-    expect(activeConversation.__loopNotices).toEqual([notice]);
 
     activeConversation.__loopDeferred.resolve();
     await activeConversation.__loopDeferred.promise;
     await Promise.resolve();
-
-    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
-  });
-
-  test("clears the Slack runtime notice after normal message processing", async () => {
-    const notice =
-      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
-
-    const processing = processMessage(
-      "conv-background-slack",
-      "Reply from Slack",
-      undefined,
-      {
-        slackRuntimeContextNotice: notice,
-        isInteractive: true,
-      },
-      "slack",
-      "slack",
-    );
-
-    await waitForRunAgentLoopCall();
-
-    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
-    expect(activeConversation.__loopNotices).toEqual([notice]);
-
-    activeConversation.__loopDeferred.resolve();
-    await expect(processing).resolves.toEqual({
-      messageId: "persisted-user-message-id",
-    });
-
-    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
-    expect(activeConversation.__clientSenders).toHaveLength(2);
   });
 
   test("observes live agent events without replacing the broadcast emitter", async () => {

package/src/__tests__/process-message-display-content.test.ts

@@ -196,7 +196,6 @@ function makeTestConversation() {
         metadata,
         displayContent,
       ),
-    setSlackRuntimeContextNotice: () => {},
     runAgentLoop,
     updateClient: () => {},
     getCurrentSender: () => undefined,
@@ -361,6 +360,7 @@ describe("processMessage displayContent", () => {
     expect(persistedBlocks).toEqual([
       {
         type: "file",
+        _attachmentId: "att-1",
         source: {
           type: "base64",
           media_type: "application/pdf",
@@ -370,21 +370,26 @@ describe("processMessage displayContent", () => {
       },
     ]);
     expect(addMessageCalls[0]!.content).not.toContain("<external_content");
-    expect(conversation.getMessages()[0]).toEqual({
-      role: "user",
-      content: [
-        { type: "text", text: modelContent },
-        {
-          type: "file",
-          source: {
-            type: "base64",
-            media_type: "application/pdf",
-            data: Buffer.from("pdf bytes").toString("base64"),
-            filename: "attachment.pdf",
-          },
-          extracted_text: undefined,
-        },
-      ],
+    const inMemoryMessage = conversation.getMessages()[0]!;
+    expect(inMemoryMessage.role).toBe("user");
+    expect(inMemoryMessage.content[0]).toEqual({
+      type: "text",
+      text: modelContent,
+    });
+    const inMemoryFileBlock = inMemoryMessage.content[1] as unknown as Record<
+      string,
+      unknown
+    >;
+    expect(inMemoryFileBlock._attachmentId).toBe("att-1");
+    expect(inMemoryFileBlock).toMatchObject({
+      type: "file",
+      source: {
+        type: "base64",
+        media_type: "application/pdf",
+        data: Buffer.from("pdf bytes").toString("base64"),
+        filename: "attachment.pdf",
+      },
+      extracted_text: undefined,
     });
   });
 

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;