@vellumai/assistant 0.12.5-dev.202609252314.2f8433a → 0.12.5-dev.202609260125.8a6a403

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609252314.2f8433a",
+  "version": "0.12.5-dev.202609260125.8a6a403",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/desktop/desktop-chrome-policy.ts

@@ -23,12 +23,14 @@ export function writeDesktopChromePolicy(policyDir: string): void {
     }
   }
   if (
+    policy.NetworkPredictionOptions === 2 &&
     policy.CommandLineFlagSecurityWarningsEnabled === false &&
     policy.PasswordManagerEnabled === false
   ) {
     return;
   }
 
+  policy.NetworkPredictionOptions = 2;
   // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
   policy.CommandLineFlagSecurityWarningsEnabled = false;
   // Suppress save prompts while keeping previously saved passwords usable.

package/src/providers/fireworks/client.test.ts

@@ -0,0 +1,168 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import { RetryProvider } from "../retry.js";
+import type { Message, SendMessageOptions } from "../types.js";
+import {
+  FIREWORKS_SESSION_AFFINITY_HEADER,
+  FireworksProvider,
+  resolveFireworksRequestHeaders,
+} from "./client.js";
+
+const USER_TURN: Message[] = [
+  { role: "user", content: [{ type: "text", text: "question" }] },
+];
+
+interface WireCall {
+  params: Record<string, unknown>;
+  headers: Record<string, string> | undefined;
+}
+
+/** Replace the SDK client so each chat-completions call is recorded. */
+function stubChatCompletions(provider: OpenAIChatCompletionsProvider) {
+  const calls: WireCall[] = [];
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://api.fireworks.example/inference/v1",
+    chat: {
+      completions: {
+        create: async (
+          params: Record<string, unknown>,
+          options?: { headers?: Record<string, string> },
+        ) => {
+          calls.push({ params, headers: options?.headers });
+          return {
+            async *[Symbol.asyncIterator]() {
+              yield {
+                choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+                usage: { prompt_tokens: 2, completion_tokens: 1 },
+              };
+            },
+          };
+        },
+      },
+    },
+  };
+  return calls;
+}
+
+function fireworksPipeline() {
+  const inner = new FireworksProvider(
+    "fw-test",
+    "accounts/fireworks/models/example-model",
+  );
+  const calls = stubChatCompletions(inner);
+  return { provider: new RetryProvider(inner), calls };
+}
+
+async function send(
+  provider: RetryProvider,
+  config: SendMessageOptions["config"],
+): Promise<void> {
+  await provider.sendMessage(USER_TURN, { config });
+}
+
+beforeEach(() => {
+  setConfig("llm", {});
+});
+
+describe("resolveFireworksRequestHeaders", () => {
+  test("sets the session affinity header from the key", () => {
+    expect(resolveFireworksRequestHeaders("conv-xyz")).toEqual({
+      [FIREWORKS_SESSION_AFFINITY_HEADER]: "conv-xyz",
+    });
+  });
+
+  test("omits the header without a usable key", () => {
+    expect(resolveFireworksRequestHeaders(undefined)).toEqual({});
+    expect(resolveFireworksRequestHeaders("   ")).toEqual({});
+  });
+});
+
+describe("Fireworks session affinity on the wire", () => {
+  test("sends the selectionSeed as x-session-affinity and keeps it out of the body", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {
+      selectionSeed: "conv-seed",
+      conversationId: "conv-other",
+    });
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]).toBe(
+      "conv-seed",
+    );
+    const body = JSON.stringify(calls[0]!.params);
+    expect(body).not.toContain(FIREWORKS_SESSION_AFFINITY_HEADER);
+    expect(body).not.toContain("conv-seed");
+    expect(body).not.toContain("conv-other");
+    expect(calls[0]!.params).not.toHaveProperty("requestHeaders");
+    expect(calls[0]!.params).not.toHaveProperty("user");
+  });
+
+  test("falls back to conversationId when there is no selectionSeed", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, { conversationId: "conv-xyz" });
+
+    expect(calls[0]!.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]).toBe(
+      "conv-xyz",
+    );
+    expect(JSON.stringify(calls[0]!.params)).not.toContain("conv-xyz");
+  });
+
+  test("uses the same key on every call of a conversation", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, { selectionSeed: "conv-xyz" });
+    await send(provider, { selectionSeed: "conv-xyz" });
+
+    expect(
+      calls.map((call) => call.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]),
+    ).toEqual(["conv-xyz", "conv-xyz"]);
+  });
+
+  test("sends no header when the call has no conversation key", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {});
+    await send(provider, { selectionSeed: "  ", conversationId: "" });
+
+    for (const call of calls) {
+      expect(call.headers ?? {}).not.toHaveProperty(
+        FIREWORKS_SESSION_AFFINITY_HEADER,
+      );
+    }
+  });
+
+  test("ignores caller-set request headers", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {
+      requestHeaders: { [FIREWORKS_SESSION_AFFINITY_HEADER]: "shared-key" },
+    });
+
+    expect(calls[0]!.headers ?? {}).not.toHaveProperty(
+      FIREWORKS_SESSION_AFFINITY_HEADER,
+    );
+  });
+
+  test("does not send the header for other chat-completions providers", async () => {
+    const inner = new OpenAIChatCompletionsProvider("sk-test", "some-model", {
+      providerName: "together",
+      providerLabel: "Together",
+    });
+    const calls = stubChatCompletions(inner);
+    const provider = new RetryProvider(inner);
+
+    await send(provider, {
+      selectionSeed: "conv-xyz",
+      conversationId: "conv-xyz",
+    });
+
+    expect(calls[0]!.headers ?? {}).not.toHaveProperty(
+      FIREWORKS_SESSION_AFFINITY_HEADER,
+    );
+    expect(JSON.stringify(calls[0]!.params)).not.toContain("conv-xyz");
+  });
+});

package/src/providers/fireworks/client.ts

@@ -12,6 +12,30 @@ export interface FireworksProviderOptions {
 
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
+/**
+ * Fireworks routing hint. Prompt caching works only within one replica, so
+ * serverless and multi-replica deployments use this header to send requests
+ * that share a key to the same replica.
+ * https://docs.fireworks.ai/guides/prompt-caching#optimizing-inference-request-for-caching
+ */
+export const FIREWORKS_SESSION_AFFINITY_HEADER = "x-session-affinity";
+
+/**
+ * Headers for one outgoing Fireworks request. `sessionKey` is the durable
+ * per-conversation key; without one the header is omitted, because a shared
+ * key would pin all keyless traffic to a single replica. Transport metadata
+ * only; nothing here enters the request body.
+ */
+export function resolveFireworksRequestHeaders(
+  sessionKey: string | undefined,
+): Record<string, string> {
+  const key = sessionKey?.trim();
+  if (!key) {
+    return {};
+  }
+  return { [FIREWORKS_SESSION_AFFINITY_HEADER]: key };
+}
+
 const FIREWORKS_MODEL_EFFORT_CEILINGS = modelEffortCeilings("fireworks");
 const FIREWORKS_MODEL_SUPPORTED_EFFORTS = modelSupportedEfforts("fireworks");
 

package/src/providers/retry.ts

@@ -35,6 +35,7 @@ import {
   shouldSkipPrimary,
   tryAcquireRecoveryProbe,
 } from "./fallback-breaker.js";
+import { resolveFireworksRequestHeaders } from "./fireworks/client.js";
 import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
 import { MALFORMED_TOOL_CALL_MESSAGE } from "./malformed-tool-call.js";
 import {
@@ -681,6 +682,19 @@ function normalizeSendMessageOptions(
     nextConfig.requestHeaders = resolveOpenCodeRequestHeaders(conversationId);
   }
 
+  if (providerName === "fireworks") {
+    // Covers BYOK Fireworks and the Vellum-managed Fireworks upstream, which
+    // both dispatch through `FireworksProvider`. Keyless calls send no header.
+    const sessionKey = [config.selectionSeed, config.conversationId].find(
+      (value): value is string =>
+        typeof value === "string" && value.trim().length > 0,
+    );
+    const headers = resolveFireworksRequestHeaders(sessionKey);
+    if (Object.keys(headers).length > 0) {
+      nextConfig.requestHeaders = headers;
+    }
+  }
+
   // `overrideProfile`, `forceOverrideProfile`, `selectionSeed`,
   // `conversationId`, and `nativeWebSearchSentinel` are routing/resolution-time
   // concerns (consumed by the resolver below, `CallSiteRoutingProvider`'s

package/src/providers/types.ts

@@ -412,8 +412,9 @@ export interface SendMessageConfig {
   usageAttributionHeaders?: Record<string, string>;
   /**
    * Per-request HTTP headers merged onto the transport. `RetryProvider`
-   * stamps these for providers that need support-lookup headers (OpenCode
-   * `x-opencode-session` / `x-opencode-request`). Provider clients pass
+   * stamps these for providers that need per-conversation routing headers
+   * (OpenCode `x-opencode-session` / `x-opencode-request`, Fireworks
+   * `x-session-affinity`). Provider clients pass
    * them through SDK request options only and must never include this
    * object in provider JSON request bodies.
    */