@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/providers/__tests__/count-tokens-forwarding.test.ts

@@ -0,0 +1,98 @@
+/**
+ * The production conversation provider is wrapped (CallSiteRouting → RateLimit
+ * → Retry → UsageTracking → adapter). `Provider.countInputTokens` is optional,
+ * so each wrapper must forward it or the capability is lost partway up the
+ * chain and `/compact` silently falls back to the local estimate. These tests
+ * pin the forwarding.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+import { CallSiteRoutingProvider } from "../call-site-routing.js";
+import { RateLimitProvider } from "../ratelimit.js";
+import { RetryProvider } from "../retry.js";
+import type { Message, Provider } from "../types.js";
+import { UsageTrackingProvider } from "../usage-tracking.js";
+
+function providerWithCount(): Provider {
+  return {
+    name: "inner",
+    sendMessage: async () => ({
+      content: [],
+      model: "m",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      stopReason: "end_turn",
+    }),
+    countInputTokens: async () => 4242,
+  };
+}
+
+function providerWithoutCount(): Provider {
+  const p = providerWithCount();
+  delete p.countInputTokens;
+  return p;
+}
+
+const msgs: Message[] = [
+  { role: "user", content: [{ type: "text", text: "hi" }] },
+];
+
+const wrappers: Array<[string, (inner: Provider) => Provider]> = [
+  ["RetryProvider", (inner) => new RetryProvider(inner)],
+  ["UsageTrackingProvider", (inner) => new UsageTrackingProvider(inner)],
+  [
+    "RateLimitProvider",
+    (inner) => new RateLimitProvider(inner, { maxRequestsPerMinute: 0 }),
+  ],
+  [
+    "CallSiteRoutingProvider",
+    (inner) => new CallSiteRoutingProvider(inner, async () => null),
+  ],
+];
+
+describe("countInputTokens forwarding through provider wrappers", () => {
+  for (const [name, wrap] of wrappers) {
+    test(`${name} forwards the count when the inner provider supports it`, async () => {
+      const wrapped = wrap(providerWithCount());
+      expect(typeof wrapped.countInputTokens).toBe("function");
+      expect(await wrapped.countInputTokens!(msgs, "sys", undefined)).toBe(
+        4242,
+      );
+    });
+
+    test(`${name} omits the count when the inner provider lacks it`, () => {
+      const wrapped = wrap(providerWithoutCount());
+      expect(wrapped.countInputTokens).toBeUndefined();
+    });
+  }
+
+  test("capability survives the full nested wrapper chain", () => {
+    const chain = new CallSiteRoutingProvider(
+      new RateLimitProvider(
+        new RetryProvider(new UsageTrackingProvider(providerWithCount())),
+        { maxRequestsPerMinute: 0 },
+      ),
+      async () => null,
+    );
+    expect(typeof chain.countInputTokens).toBe("function");
+  });
+});

package/src/providers/__tests__/provider-env-vars.test.ts

@@ -35,6 +35,7 @@ describe("getLlmProviderEnvVar", () => {
     expect(getLlmProviderEnvVar("brave")).toBeUndefined();
     expect(getLlmProviderEnvVar("perplexity")).toBeUndefined();
     expect(getLlmProviderEnvVar("tavily")).toBeUndefined();
+    expect(getLlmProviderEnvVar("firecrawl")).toBeUndefined();
   });
 
   test("returns undefined for unknown provider", () => {
@@ -55,6 +56,10 @@ describe("getSearchProviderEnvVar", () => {
     expect(getSearchProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
   });
 
+  test("returns FIRECRAWL_API_KEY for firecrawl", () => {
+    expect(getSearchProviderEnvVar("firecrawl")).toBe("FIRECRAWL_API_KEY");
+  });
+
   test("returns undefined for LLM providers (out of scope)", () => {
     expect(getSearchProviderEnvVar("anthropic")).toBeUndefined();
     expect(getSearchProviderEnvVar("openai")).toBeUndefined();
@@ -75,6 +80,7 @@ describe("getAnyProviderEnvVar", () => {
     expect(getAnyProviderEnvVar("brave")).toBe("BRAVE_API_KEY");
     expect(getAnyProviderEnvVar("perplexity")).toBe("PERPLEXITY_API_KEY");
     expect(getAnyProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
+    expect(getAnyProviderEnvVar("firecrawl")).toBe("FIRECRAWL_API_KEY");
   });
 
   test("returns undefined for ollama (keyless LLM provider)", () => {

package/src/providers/__tests__/provider-secret-catalog.test.ts

@@ -44,5 +44,6 @@ describe("API_KEY_PROVIDERS", () => {
     expect(API_KEY_PROVIDERS).toContain("brave");
     expect(API_KEY_PROVIDERS).toContain("perplexity");
     expect(API_KEY_PROVIDERS).toContain("tavily");
+    expect(API_KEY_PROVIDERS).toContain("firecrawl");
   });
 });

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

@@ -425,6 +425,62 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.temperature).toBe(0.5);
   });
 
+  test("forwards resolved topP to wire `top_p` (non-thinking provider)", async () => {
+    // `topP` (schema, camelCase) renames to `top_p` on the wire, mirroring
+    // `maxTokens`→`max_tokens`. Fireworks has no thinking constraint, so the
+    // value passes straight through.
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.top_p).toBe(0.95);
+  });
+
+  test("does NOT forward top_p when resolved topP is null (schema default)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        // `topP` defaults to null — "let provider pick".
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    // Must NOT be set — `top_p: null` would either be a wire error or override
+    // sensible provider defaults, mirroring the `temperature` handling.
+    expect(config.top_p).toBeUndefined();
+    expect("top_p" in config).toBe(false);
+  });
+
   test("strips effort/speed for providers that don't support them (e.g. fireworks)", async () => {
     setLlmConfig({
       default: {
@@ -773,6 +829,126 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
   });
 });
 
+// ── RetryProvider — Anthropic thinking + top_p conflict guard ───────────────
+//
+// Anthropic rejects *any* `top_p` modification when extended thinking is
+// enabled (same constraint family as `temperature` ≠ 1, but with no
+// "=== 1 is fine" exception). This guard drops the offending `top_p` so the
+// request goes through with Anthropic's default instead of 400ing at the wire.
+
+describe("RetryProvider — thinking/top_p conflict guard", () => {
+  test("drops top_p when thinking is enabled (Anthropic)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "adaptive" });
+    expect(config.top_p).toBeUndefined();
+    expect("top_p" in config).toBe(false);
+  });
+
+  test("drops top_p for OpenRouter when fronting an `anthropic/*` model", async () => {
+    setLlmConfig({
+      default: {
+        provider: "openrouter",
+        model: "anthropic/claude-opus-4-7",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.9,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("openrouter", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.model).toBe("anthropic/claude-opus-4-7");
+    expect(config.top_p).toBeUndefined();
+  });
+
+  test("preserves top_p when thinking is enabled on a non-Anthropic provider (fireworks)", async () => {
+    // Fireworks (and other non-Anthropic providers) don't share Anthropic's
+    // top_p-with-thinking constraint — the guard must not over-reach. Note
+    // that fireworks strips `thinking` itself, but `top_p` stays.
+    setLlmConfig({
+      default: {
+        provider: "fireworks",
+        model: "fireworks-model",
+        thinking: { enabled: true, streamThinking: true },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("fireworks", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.top_p).toBe(0.95);
+  });
+
+  test("preserves top_p when thinking is disabled (Anthropic)", async () => {
+    setLlmConfig({
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        thinking: { enabled: false, streamThinking: false },
+        topP: 0.95,
+      },
+      callSites: { mainAgent: {} },
+    });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.thinking).toEqual({ type: "disabled" });
+    expect(config.top_p).toBe(0.95);
+  });
+});
+
 // ── RetryProvider — pre-resolved model fast-path ────────────────────────────
 
 describe("RetryProvider — no callSite (pre-resolved config passes through)", () => {