@providerkit/core 0.17.2 → 0.21.0

package/src/auth/oauth.ts

@@ -0,0 +1,226 @@
+// The OAuth plumbing every signed-in provider shares: PKCE, the token POST, the
+// credential it builds, and the errors a sign-in can end in. Fetch only, no
+// Node built-ins. What differs per vendor stays in flows.ts.
+import { classifyHttp, ProviderError } from "../errors.ts";
+
+/** What the host app supplies. Opening a browser and catching a redirect are
+ *  the two things a fetch-only package can't do. */
+export interface AuthHost {
+  /** Names the app on the wire: Copilot's `Editor-Version`, xAI's `referrer`.
+   *  Use `name/version`, like `TabRunner/1.4.0`. */
+  appName: string;
+  /** Opens a page for the user. Device-code flows call it with the approval page. */
+  openUrl(url: string): void | Promise<void>;
+  /**
+   * Opens `authorizeUrl`, waits for the browser to land on `redirectUri`, and
+   * returns the `code` from that URL. Reject with a `SignInError` when the user
+   * denies (`denied`), closes the page (`cancelled`) or takes too long
+   * (`expired`). Check `state` against the one in the URL when it is set.
+   */
+  captureRedirect(request: {
+    authorizeUrl: string;
+    redirectUri: string;
+    state?: string;
+    signal: AbortSignal;
+  }): Promise<string>;
+  /** Replaces `fetch`, for tests. */
+  fetchImpl?: typeof fetch;
+}
+
+/** The stored result of a sign-in. */
+export interface Credential {
+  accessToken: string;
+  /** What renews `accessToken`. Copilot keeps the GitHub token here and Meta
+   *  its identity token. Empty for a key that never expires (OpenRouter). */
+  refreshToken: string;
+  /** Epoch ms, already moved earlier by {@link REFRESH_SKEW_MS}: refresh at or
+   *  after this, it is not the server's own expiry. */
+  expiresAt: number;
+  /** For display: the account the token belongs to. */
+  account?: string;
+  /** ChatGPT only: send it as the `ChatGPT-Account-Id` header. */
+  chatgptAccountId?: string;
+  /** Set when the vendor gives each account its own host (Copilot). */
+  baseUrl?: string;
+}
+
+export type SignInFailure = "denied" | "expired" | "cancelled";
+
+/** How a sign-in ended without a credential. The reason picks the wording. */
+export class SignInError extends Error {
+  constructor(readonly reason: SignInFailure) {
+    super(reason);
+    this.name = "SignInError";
+  }
+}
+
+/** The coded errors a sign-in or a refresh throws, as `ProviderError.code`. */
+export type AuthErrorCode =
+  | "token_refused"
+  | "token_incomplete"
+  | "device_response_invalid"
+  | "setup_required"
+  | "refresh_dead";
+
+export function authError(
+  code: AuthErrorCode,
+  message: string,
+  opts: { status?: number; body?: string } = {},
+): ProviderError {
+  const body = opts.body ?? "";
+  // `invalid_grant` and a 401 classify as `auth`, a 429 as `rate`, a 5xx as an outage.
+  const kind = opts.status === undefined ? "auth" : classifyHttp(opts.status, body);
+  return new ProviderError("auth", kind, message, { ...opts, code });
+}
+
+/** Refresh this long before the server's own expiry. */
+export const REFRESH_SKEW_MS = 5 * 60 * 1000;
+
+export const str = (value: unknown): string | undefined =>
+  typeof value === "string" && value.length > 0 ? value : undefined;
+
+export const num = (value: unknown): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+export const asRecord = (value: unknown): Record<string, unknown> =>
+  typeof value === "object" && value !== null ? Object.fromEntries(Object.entries(value)) : {};
+
+/** RFC 7636 code verifier and S256 challenge. */
+export async function generatePKCE(): Promise<{ verifier: string; challenge: string }> {
+  const verifier = toBase64Url(crypto.getRandomValues(new Uint8Array(64)));
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { verifier, challenge: toBase64Url(new Uint8Array(digest)) };
+}
+
+/** Opaque CSRF state: 128 bits, hex. */
+export function randomState(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function toBase64Url(bytes: Uint8Array): string {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+/**
+ * POST to a token endpoint and return the parsed body.
+ *
+ * A token in the body wins over the status: a vendor can return a usable
+ * credential next to a non-2xx (Anthropic answers 429 for a plan over its usage
+ * limit). Only a body without one is an error. The device-code poll sets
+ * `allowErrorBody`, because it gets a 4xx for most of the wait.
+ */
+export async function postToken(
+  host: AuthHost,
+  url: string,
+  params: Record<string, string>,
+  opts: { encode: "json" | "form"; allowErrorBody?: boolean },
+): Promise<Record<string, unknown>> {
+  const json = opts.encode === "json";
+  const res = await (host.fetchImpl ?? fetch)(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": json ? "application/json" : "application/x-www-form-urlencoded",
+      Accept: "application/json",
+    },
+    body: json ? JSON.stringify(params) : new URLSearchParams(params).toString(),
+  });
+  const text = await res.text().catch(() => "");
+  const record = asRecord(safeJson(text));
+
+  if (isTokenPair(record)) return record;
+  if (res.ok || (opts.allowErrorBody && res.status < 500)) return record;
+
+  const detail = errorDetail(record) ?? String(res.status);
+  throw authError("token_refused", `The sign-in server refused the request: ${detail}`, {
+    status: res.status,
+    body: text.slice(0, 2_000),
+  });
+}
+
+function safeJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function isTokenPair(body: Record<string, unknown>): boolean {
+  return (
+    str(body.access_token) !== undefined &&
+    str(body.refresh_token) !== undefined &&
+    num(body.expires_in) !== undefined
+  );
+}
+
+/** A reason out of an OAuth error body: RFC 6749's `error_description` and
+ *  `error`, or the nested `error.message` Anthropic and OpenAI use. */
+export function errorDetail(record: Record<string, unknown>): string | undefined {
+  const description = str(record.error_description);
+  if (description) return description;
+  const error = record.error;
+  if (typeof error === "string") return error;
+  const nested = asRecord(error);
+  return str(nested.message) ?? str(nested.type);
+}
+
+/** The credential a token response describes. Naming the account is the
+ *  caller's job: every vendor puts it under a different claim. */
+export function toCredential(body: Record<string, unknown>, fallbackRefresh?: string): Credential {
+  const accessToken = str(body.access_token);
+  // A refresh response may leave out the refresh token. Keep the old one then.
+  const refreshToken = str(body.refresh_token) ?? fallbackRefresh;
+  const expiresIn = num(body.expires_in);
+  if (!accessToken || !refreshToken || expiresIn === undefined) {
+    throw authError(
+      "token_incomplete",
+      "The sign-in server's reply is missing a token or its expiry.",
+    );
+  }
+  return { accessToken, refreshToken, expiresAt: Date.now() + expiresIn * 1000 - REFRESH_SKEW_MS };
+}
+
+/** A JWT's payload, read WITHOUT checking the signature. Safe here because
+ *  nothing is authorized on it: it only names the account for display. */
+export function jwtClaims(token?: string): Record<string, unknown> | undefined {
+  const payload = token?.split(".")[1];
+  if (!payload) return undefined;
+  try {
+    return asRecord(JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/"))));
+  } catch {
+    return undefined;
+  }
+}
+
+/** The account a token names, trying the claims in order. An email wins and is
+ *  lowercased, because one mailbox written two ways is one account. */
+export function accountFromToken(
+  token: string | undefined,
+  ...claims: string[]
+): string | undefined {
+  const payload = jwtClaims(token);
+  if (!payload) return undefined;
+  for (const claim of claims) {
+    const value = str(payload[claim]);
+    if (value) return claim === "email" ? value.toLowerCase() : value;
+  }
+  return undefined;
+}
+
+/** The URL if it is http(s), else undefined. It comes off the network and ends
+ *  up in `openUrl`, so a `javascript:` or `data:` URL must not get through. */
+export function webUrl(
+  value: string | undefined,
+  protocols = ["https:", "http:"],
+): string | undefined {
+  if (!value) return undefined;
+  try {
+    const url = new URL(value);
+    return protocols.includes(url.protocol) ? url.href : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/auth/token-source.ts

@@ -0,0 +1,76 @@
+// One place that hands out a token that works: refreshes it once however many
+// callers ask, saves the new pair before anyone uses it, and recovers when a
+// second tab or process spent the refresh token first.
+import { isTransportFailure, ProviderError } from "../errors.ts";
+import { authError, type Credential } from "./oauth.ts";
+
+export interface TokenSourceOptions<C extends Credential = Credential> {
+  /** Read the stored credential. Read it on every call, never cache it: the
+   *  refresh token rotates, and a cached copy would spend one already used. */
+  load(): Promise<C | undefined>;
+  /** Persist a refreshed credential. Awaited before the new token is used. */
+  save(credential: C): Promise<void>;
+  /** Trade the credential for a fresh one: `createAuthFlow(id, host).refresh`. */
+  refresh(credential: C): Promise<C>;
+}
+
+export interface TokenSource<C extends Credential = Credential> {
+  /** A credential whose `accessToken` is good now. Throws a `ProviderError`
+   *  coded `refresh_dead` when the user must sign in again. */
+  getToken(): Promise<C>;
+}
+
+/**
+ * Refresh when the stored credential has expired, and only then.
+ *
+ * - Concurrent calls share one refresh and the result is saved before use.
+ * - When the server rejects the refresh, the stored credential is reloaded. If
+ *   another context saved a newer one meanwhile, that one is used. Otherwise
+ *   the session is dead and the error says so.
+ * - A network failure keeps the credential and rethrows, so a user on bad wifi
+ *   isn't told to sign in again.
+ *
+ * ponytail: two contexts can both lose a refresh before either one saves, and
+ * then both fail. Closing that needs a lock on the storage.
+ */
+export function tokenSource<C extends Credential>(options: TokenSourceOptions<C>): TokenSource<C> {
+  let inFlight: Promise<C> | undefined;
+
+  async function refreshStored(stale: C): Promise<C> {
+    try {
+      const fresh = await options.refresh(stale);
+      await options.save(fresh);
+      return fresh;
+    } catch (error) {
+      if (!isRejected(error)) throw error;
+      const stored = await options.load();
+      if (stored && isNewer(stored, stale) && Date.now() < stored.expiresAt) return stored;
+      throw authError("refresh_dead", "The sign-in expired and can't be renewed. Sign in again.");
+    }
+  }
+
+  return {
+    async getToken() {
+      const credential = await options.load();
+      if (!credential) {
+        throw authError("refresh_dead", "Not signed in. Sign in first.");
+      }
+      if (Date.now() < credential.expiresAt) return credential;
+      inFlight ??= refreshStored(credential).finally(() => {
+        inFlight = undefined;
+      });
+      return inFlight;
+    },
+  };
+}
+
+/** A refresh the server turned down for good, as opposed to one that never
+ *  reached it or came back unreadable. */
+function isRejected(error: unknown): error is ProviderError {
+  if (isTransportFailure(error) || !(error instanceof ProviderError)) return false;
+  return error.status === 400 || error.status === 401 || error.status === 403;
+}
+
+function isNewer(stored: Credential, stale: Credential): boolean {
+  return stored.refreshToken !== stale.refreshToken || stored.expiresAt > stale.expiresAt;
+}

package/src/context.ts

@@ -41,7 +41,22 @@ export function messageTokens(message: ChatMessage): number {
       ? (message.reasoning ?? "") +
         (message.toolCalls?.map((call) => call.name + call.arguments).join("") ?? "")
       : "";
-  return estimateTokens(textOf(message) + extra);
+  return estimateTokens(textOf(message) + extra) + reasoningItemTokens(message);
+}
+
+/**
+ * Encrypted reasoning is base64 of the real thing, so its length says little:
+ * three bytes per four characters, less ~650 bytes of envelope, then four bytes
+ * a token (cc-proxy's estimate).
+ */
+function reasoningItemTokens(message: ChatMessage): number {
+  if (message.role !== "assistant" || !message.reasoningItems) return 0;
+  let tokens = 0;
+  for (const item of message.reasoningItems.items) {
+    const blob = (item as { encrypted_content?: unknown } | null)?.encrypted_content;
+    if (typeof blob === "string") tokens += Math.max(0, ((blob.length * 3) / 4 - 650) / 4);
+  }
+  return Math.ceil(tokens);
 }
 
 export function conversationTokens(messages: readonly ChatMessage[]): number {

package/src/errors.ts

@@ -423,6 +423,9 @@ const AUTH_PATTERNS: readonly RegExp[] = [
   /account (?:disabled|suspended|deactivated|banned)/i,
   /unrecognizedclient|unauthorizedexception|accessdeniedexception/i,
   /expired[_\s]?token/i,
+  // OAuth's answer to a refresh token that was revoked, spent or expired. It
+  // arrives as a 400, which on status alone reads as `invalid`.
+  /\binvalid_grant\b/i,
   /OAuth token has been revoked/i,
   // Cloudflare's code 7003, for an account id that names no account. It
   // arrives as a 404, which on status alone reads as a missing model — but

package/src/presets.ts

@@ -7,7 +7,7 @@
  * they drift on a vendor's schedule and a wrong number in a library is a
  * wrong number in everyone's ledger), icons, colors, marketing names, and
  * sign-in flows (an `oauth` preset expects the CALLER to hand over an access
- * token; acquiring one stays app-side).
+ * token; `@providerkit/core/auth` is how to get and renew one).
  *
  * Sources: the coding-plan endpoints and auth quirks are measured
  * (tabrunner's extension + this repo's adopters, 2026-09); the model lists
@@ -31,11 +31,26 @@ export type PresetShape = "anthropic" | "openai" | "responses" | "gemini";
  *   coding-plan gateways' mode on the Anthropic wire (measured: Z.ai's coding
  *   endpoint ignores `x-api-key` and reads Bearer).
  * - `oauth`: same wire as `bearer`, but the token is a short-lived access
- *   token from a sign-in flow the caller owns. The preset may carry the beta
+ *   token from a sign-in flow (see `@providerkit/core/auth`). The preset may carry the beta
  *   headers that switch the endpoint into OAuth mode.
  */
 export type PresetAuth = "key" | "bearer" | "oauth";
 
+/**
+ * One wire a preset serves besides its own. A gateway that puts different
+ * models on different wires (OpenCode Go) lists the exceptions here, and the
+ * preset's own `shape` and `baseUrl` serve every other model.
+ */
+export interface PresetRoute {
+  /** The model ids this route serves, matched by prefix. */
+  prefixes: readonly string[];
+  shape: PresetShape;
+  baseUrl: string;
+  path?: string;
+  /** Defaults to the preset's `auth`. */
+  auth?: PresetAuth;
+}
+
 export interface ProviderPreset {
   /** Adapter wire format. */
   shape: PresetShape;
@@ -70,12 +85,24 @@ export interface ProviderPreset {
    *  and cache per conversation — and refuse a call without it (OpenCode Go:
    *  `MissingSessionID`, measured 2026-09-27). */
   sessionHeader?: string;
+  /** Wires for model ids that don't use the preset's own `shape`. The first
+   *  route with a matching prefix serves the model. A model on a different wire
+   *  than the one the provider was built for is refused with `invalid`, so a
+   *  per-call `model` can't send a request to an endpoint that would 404 it. */
+  routes?: readonly PresetRoute[];
   /** Default model chain when the caller names neither `model` nor `models`:
    *  the first answers, the rest take over (same key) when it fails. */
   rotation?: readonly string[];
   /** Responses shape: what the backend accepts as an image, for backends that
    *  fail a whole request over one image they won't take. */
   imageLimits?: ImageLimits;
+  /** Responses shape: ask for the encrypted reasoning items, and send them back
+   *  on the next turn. Only for backends that take `include`; `chatgpt` is the
+   *  one that does, and Go and Grok may refuse it. */
+  replayReasoning?: boolean;
+  /** OpenAI shape: send `X-Initiator` (`user` or `agent`) on every call. GitHub
+   *  Copilot bills a premium request per `user` turn. */
+  initiatorHeader?: boolean;
 }
 
 export const PROVIDER_PRESETS = {
@@ -329,22 +356,6 @@ export const PROVIDER_PRESETS = {
     defaultModel: "glm-5.3-flash",
     models: ["glm-5.3-flash", "glm-5.3", "glm-5.2"],
   },
-  /**
-   * OpenCode Go's Responses route. Muse Contributor measured 2026-09-28:
-   * text, images, strict JSON Schema, parallel tools and tool-result round trips
-   * all passed. It requires reasoning (`none` becomes `minimal`) and accepts
-   * only automatic tool choice (`none` is encoded by sending no tools).
-   * Contributor requests may be used to improve Meta products; the workspace
-   * must explicitly allow those endpoints.
-   */
-  "opencode-go-responses": {
-    shape: "responses",
-    baseUrl: "https://opencode.ai/zen/go",
-    auth: "bearer",
-    defaultModel: "muse-spark-1.3-contributor",
-    models: ["muse-spark-1.3-contributor"],
-    sessionHeader: "x-opencode-session",
-  },
   /**
    * OpenCode Go — one $10/month key across many open models, each with its own
    * monthly dollar limit (5h = 20%, week = 50%). Chain several models as
@@ -355,17 +366,50 @@ export const PROVIDER_PRESETS = {
    * `reasoning_effort: "none"`, tool calls and json_schema; `glm-5.3-flash`
    * 400s on a tool without a description and on a `thinking` field.
    *
-   * This preset speaks chat completions only. Go serves GPT/Grok/Muse Spark on
-   * /responses and some Qwen/MiniMax ids on Anthropic /messages — those ids
-   * fail here.
+   * Go serves three wires, and `routes` picks one from the model id (cc-proxy's
+   * table, from Go's own docs): `minimax-` and `qwen` on Anthropic /messages
+   * (key in `x-api-key`), `gpt-`, `grok-` and `muse-spark-` on /responses, and
+   * everything else on chat completions. Each model in a chain resolves its
+   * own route, so one preset serves a chain that crosses wires.
+   *
+   * Muse Contributor, measured 2026-09-28 on /responses: text, images, strict
+   * JSON Schema, parallel tools and tool-result round trips all passed. It
+   * requires reasoning (`none` becomes `minimal`) and accepts only automatic
+   * tool choice (`none` is encoded by sending no tools). Contributor requests
+   * may be used to improve Meta products; the workspace must explicitly allow
+   * those endpoints.
+   *
+   * Reasoning effort is spelled per model on chat completions (see
+   * `effortParams`): GLM takes only `high` and `max`, DeepSeek V4 and MiMo
+   * take graded levels.
    */
   "opencode-go": {
     shape: "openai",
     baseUrl: "https://opencode.ai/zen/go/v1",
     auth: "bearer",
     defaultModel: "mimo-v2.6-flash",
-    models: ["mimo-v2.6-flash", "mimo-v2.5", "glm-5.3-flash", "qwen3.8-flash", "longcat-2.0"],
+    models: [
+      "mimo-v2.6-flash",
+      "mimo-v2.5",
+      "glm-5.3-flash",
+      "qwen3.8-flash",
+      "longcat-2.0",
+      "muse-spark-1.3-contributor",
+    ],
     sessionHeader: "x-opencode-session",
+    routes: [
+      {
+        prefixes: ["minimax-", "qwen"],
+        shape: "anthropic",
+        baseUrl: "https://opencode.ai/zen/go",
+        auth: "key",
+      },
+      {
+        prefixes: ["gpt-", "grok-", "muse-spark-"],
+        shape: "responses",
+        baseUrl: "https://opencode.ai/zen/go",
+      },
+    ],
     // Cheapest first, each with its own monthly limit ($60, qwen3.8-flash $30).
     // All five passed plain text, a described tool call and json_schema on
     // 2026-09-27; longcat-2.0 ignores reasoning "none", so it goes last.
@@ -445,7 +489,7 @@ export const PROVIDER_PRESETS = {
     auth: "bearer",
   },
 
-  // ── OAuth — the caller owns the sign-in flow and hands over the token ───
+  // ── OAuth — sign in with `@providerkit/core/auth`, hand over the token ──
   claude: {
     shape: "anthropic",
     baseUrl: "https://api.anthropic.com",
@@ -493,6 +537,7 @@ export const PROVIDER_PRESETS = {
       "gpt-5.6-luna",
       "gpt-5.5",
     ],
+    replayReasoning: true,
   },
   /**
    * A Grok subscription (SuperGrok, X Premium) — the backend the Grok CLI
@@ -530,12 +575,33 @@ export const PROVIDER_PRESETS = {
     auth: "oauth",
     defaultModel: "kimi-for-coding",
   },
+  /**
+   * GitHub Copilot, on an individual seat's host. Other plans have their own
+   * host, which the sign-in returns as `credential.baseUrl`: pass it as
+   * `baseUrl`. Copilot serves chat at `/chat/completions` with no `/v1`, and the
+   * default path would have added one and 404'd.
+   *
+   * The headers are the ones its gate checks on every call. Pass
+   * `copilotHeaders(appName, "user")` from `@providerkit/core/auth` in
+   * `headers` to name your app in `Editor-Version`. `X-Initiator` is set per
+   * call, because it decides what Copilot bills.
+   */
   "github-copilot": {
     shape: "openai",
-    baseUrl: "https://api.githubcopilot.com",
+    baseUrl: "https://api.individual.githubcopilot.com",
+    path: "/chat/completions",
     auth: "oauth",
     defaultModel: "gpt-5.6-sol",
     models: ["gpt-5.6-sol", "claude-opus-5", "claude-sonnet-5", "gpt-6-astra"],
+    headers: {
+      "Copilot-Integration-Id": "vscode-chat",
+      "Editor-Version": "providerkit",
+      "Editor-Plugin-Version": "providerkit",
+      "X-GitHub-Api-Version": "2026-06-01",
+      "Openai-Intent": "conversation-edits",
+      "Copilot-Vision-Request": "true",
+    },
+    initiatorHeader: true,
   },
 } as const satisfies Record<string, ProviderPreset>;
 

package/src/providers/anthropic.ts

@@ -1,5 +1,5 @@
 // Anthropic-shape adapter — SSE from POST /v1/messages.
-import { fileRefused, streamCut, streamError } from "../errors.ts";
+import { fileRefused, ProviderError, streamCut, streamError } from "../errors.ts";
 import { schemaPrompt, toAnthropicToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
@@ -51,6 +51,9 @@ export interface AnthropicConfig extends ProviderFallbackConfig {
   /** Send the key as a Bearer instead of `x-api-key` — what a subscription
    *  access token needs. */
   bearer?: boolean;
+  /** Header that carries `StreamOptions.sessionId`. When set and a call has no
+   *  sessionId, one stable id for this provider instance rides instead. */
+  sessionHeader?: string;
   /** Say "no thinking" with an explicit `thinking: { type: "disabled" }` when
    *  effort resolves to none, instead of omitting the field. For endpoints
    *  where an absent field means the MODEL's default, not off — Z.ai's coding
@@ -356,6 +359,7 @@ interface AnthropicEvent {
 export function createAnthropicProvider(config: AnthropicConfig): Provider {
   const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
   const id = config.id ?? "anthropic";
+  const instanceSessionId = config.sessionHeader ? crypto.randomUUID() : undefined;
 
   const provider: Provider = {
     id,
@@ -371,6 +375,15 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
       const effort = opts.effort ?? config.effort;
       const { system, messages: body } = toAnthropicMessages(messages, id);
 
+      // Anthropic's own `service_tier` means auto or standard_only, not this.
+      if (opts.serviceTier) {
+        throw new ProviderError(
+          id,
+          "invalid",
+          `${id}: Anthropic has no priority or flex tier (its service_tier field means something else). ` +
+            "Leave serviceTier unset for Claude models.",
+        );
+      }
       const request: Record<string, unknown> = {
         model,
         max_tokens: maxTokens,
@@ -487,6 +500,9 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
             ? { authorization: `Bearer ${config.apiKey}` }
             : { "x-api-key": config.apiKey }),
           ...attributionHeaders(config, config.headers),
+          ...(config.sessionHeader
+            ? { [config.sessionHeader]: opts.sessionId ?? instanceSessionId }
+            : {}),
           ...config.headers,
         },
         body: request,