@broberg/ai-sdk 0.33.0 → 0.35.0

package/dist/{chunk-V2PD522L.js → chunk-Y3EMGZFH.js}

@@ -6,15 +6,30 @@ var DEFAULT_TIER_MAP = {
   cheap: { provider: "mistral", model: "mistral-small-latest", transport: "http" },
   // Vision: small-latest (vision-capable, cheap EU) is the default; override to
   // mistral-large-latest for demanding image/spatial/composition work.
-  vision: { provider: "mistral", model: "mistral-small-latest", transport: "http" },
+  // F041 — bumped from mistral-small on Christian's ask, and the choice is MEASURED,
+  // not assumed from price. On a fine-discrimination test (an 8x10 grid where one cell
+  // differs only in its blue channel, 190->150) across 9 cases:
+  //   mistral-medium-latest  4/9      <- best
+  //   mistral-small-latest   1/6 + 0/3 = 1/9
+  //   mistral-large-latest   0/9      <- WORSE than small, despite costing 5x more
+  // Large ties small on easy colour blocks (4/4 each) and collapses on subtle ones,
+  // so "bigger is better at vision" does not hold in Mistral's lineup. Nobody is good
+  // at this task; medium is simply the only one that sees anything.
+  vision: { provider: "mistral", model: "mistral-medium-latest", transport: "http" },
   // Native video understanding — Gemini leads; flash-lite is the cheap default (F019).
   // NOT Anthropic → out of the F030 phase-out (its own EU epic if/when needed).
   video: { provider: "gemini", model: "gemini-2.5-flash-lite", transport: "http" },
   // NOT Anthropic → out of F030 (EU-embedding migration is its own future epic).
   embedding: { provider: "openai", model: "text-embedding-3-small", transport: "http" }
 };
-function resolveTier(tier, override, configMap) {
+function resolveTier(tier, override, configMap, knownProviders) {
   const base = configMap?.[tier] ?? DEFAULT_TIER_MAP[tier];
+  const providerIsReal = knownProviders === void 0 || knownProviders.includes(override?.provider ?? "");
+  if (providerIsReal && override?.provider && override.model === void 0 && override.provider !== base.provider) {
+    throw new Error(
+      `createAI: override sets provider "${override.provider}", but tier "${tier}" resolves to model "${base.model}", which belongs to "${base.provider}". Set a model too, e.g. override: { provider: "${override.provider}", model: "<a ${override.provider} model>" }.`
+    );
+  }
   return { ...base, ...override };
 }
 
@@ -34,6 +49,7 @@ var DEFAULTS = [
   { id: "text-embedding-3-small", aliases: [], provider: "openai", available: true, status: "available", source: "default" },
   // ── Mistral (EU / GDPR) ──────────────────────────────────────────────────
   { id: "mistral-large-latest", aliases: ["mistral-large"], provider: "mistral", available: true, status: "available", source: "default" },
+  { id: "mistral-medium-latest", aliases: ["mistral-medium"], provider: "mistral", available: true, status: "available", source: "default" },
   { id: "mistral-small-latest", aliases: ["mistral-small"], provider: "mistral", available: true, status: "available", source: "default" }
 ];
 var TIER_ALIAS_CONFLICTS = [];
@@ -178,4 +194,4 @@ export {
   listModels,
   resolveModel
 };
-//# sourceMappingURL=chunk-V2PD522L.js.map
+//# sourceMappingURL=chunk-Y3EMGZFH.js.map

package/dist/chunk-Y3EMGZFH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing/tier-map.ts","../src/availability/registry.ts","../src/availability/types.ts","../src/availability/resolve.ts"],"sourcesContent":["// Tier routing: a named Tier resolves to a concrete (provider, model, transport).\n// Precedence is per-call override > client config map > built-in defaults.\nimport type { Tier, TierSpec } from \"../types.js\";\n\n/** Built-in defaults. Every entry is overridable via AiConfig.defaults or a\n *  per-call override.\n *\n *  F030 — Anthropic API phase-out: `ANTHROPIC_API_KEY` was globally removed, so the\n *  default cloud route may NOT hit Anthropic Console. `fast`/`smart`/`powerful`/\n *  `vision` now default to **Mistral EU** (Paris-hosted, Schrems II-safe — so every\n *  default text/vision call is GDPR-safe by default). Claude stays reachable as a\n *  NON-default quality fallback for non-PII via `override:{provider:\"openrouter\",\n *  model:\"anthropic/claude-…\"}`. DeepSeek (CN) is the opt-in non-PII secondary\n *  (`provider:\"deepseek\"`), never a default. Magistral (reasoning) / mistral-large\n *  for vision are per-call overrides, not defaults (don't pay the premium on all). */\nexport const DEFAULT_TIER_MAP: Record<Tier, TierSpec> = {\n  fast: { provider: \"mistral\", model: \"mistral-small-latest\", transport: \"http\" },\n  smart: { provider: \"mistral\", model: \"mistral-large-latest\", transport: \"http\" },\n  powerful: { provider: \"mistral\", model: \"mistral-large-latest\", transport: \"http\" },\n  cheap: { provider: \"mistral\", model: \"mistral-small-latest\", transport: \"http\" },\n  // Vision: small-latest (vision-capable, cheap EU) is the default; override to\n  // mistral-large-latest for demanding image/spatial/composition work.\n  // F041 — bumped from mistral-small on Christian's ask, and the choice is MEASURED,\n  // not assumed from price. On a fine-discrimination test (an 8x10 grid where one cell\n  // differs only in its blue channel, 190->150) across 9 cases:\n  //   mistral-medium-latest  4/9      <- best\n  //   mistral-small-latest   1/6 + 0/3 = 1/9\n  //   mistral-large-latest   0/9      <- WORSE than small, despite costing 5x more\n  // Large ties small on easy colour blocks (4/4 each) and collapses on subtle ones,\n  // so \"bigger is better at vision\" does not hold in Mistral's lineup. Nobody is good\n  // at this task; medium is simply the only one that sees anything.\n  vision: { provider: \"mistral\", model: \"mistral-medium-latest\", transport: \"http\" },\n  // Native video understanding — Gemini leads; flash-lite is the cheap default (F019).\n  // NOT Anthropic → out of the F030 phase-out (its own EU epic if/when needed).\n  video: { provider: \"gemini\", model: \"gemini-2.5-flash-lite\", transport: \"http\" },\n  // NOT Anthropic → out of F030 (EU-embedding migration is its own future epic).\n  embedding: { provider: \"openai\", model: \"text-embedding-3-small\", transport: \"http\" },\n};\n\n/**\n * Resolve a Tier to a concrete TierSpec.\n *\n * Merge order (later wins): DEFAULT_TIER_MAP < configMap < override.\n * - `configMap` is the client-level AiConfig.defaults (per-tier full specs).\n * - `override` is a per-call Partial<TierSpec> — only the fields it sets win.\n */\nexport function resolveTier(\n  tier: Tier,\n  override?: Partial<TierSpec>,\n  configMap?: Partial<Record<Tier, TierSpec>>,\n  knownProviders?: readonly string[],\n): TierSpec {\n  const base = configMap?.[tier] ?? DEFAULT_TIER_MAP[tier];\n  // F043: a provider-only override used to keep the TIER's model, so\n  // `override:{provider:\"anthropic\"}` on tier \"cheap\" sent mistral-small-latest to\n  // Anthropic's endpoint. Measured by coverletter 4/4 with distinct request_ids, and\n  // it is the natural thing to write — it was literally the advice given to a repo\n  // working around a missing Mistral key, so the escape hatch produced an error that\n  // looked like \"Anthropic is down\".\n  //\n  // We REFUSE rather than re-resolve. Picking a model for the new provider would mean\n  // the SDK making a price choice on the caller's behalf, and the bill would be the\n  // only place that choice was visible. An explicit error costs one line to fix and\n  // cannot be misread.\n  // A provider the client has never heard of is a TYPO, and \"no adapter registered\n  // for \\\"nope\\\"\" is the useful thing to say about it. Telling that caller to also set\n  // a model would send them down a road that cannot work, so the mismatch guard steps\n  // aside and lets the registry answer.\n  const providerIsReal = knownProviders === undefined || knownProviders.includes(override?.provider ?? \"\");\n  if (providerIsReal && override?.provider && override.model === undefined && override.provider !== base.provider) {\n    throw new Error(\n      `createAI: override sets provider \"${override.provider}\", but tier \"${tier}\" resolves to model ` +\n        `\"${base.model}\", which belongs to \"${base.provider}\". Set a model too, e.g. ` +\n        `override: { provider: \"${override.provider}\", model: \"<a ${override.provider} model>\" }.`,\n    );\n  }\n  return { ...base, ...override };\n}\n","// F022 — the model-availability registry: the ONE source both resolveModel()\n// (spawn / call path) and listModels() (UI picker) read. A curated default seed\n// (works offline — the durable floor) plus a mutable overlay that\n// refreshAvailability() updates from the live provider list.\n//\n// Scope note: this is a LIVENESS view (is this id alive right now?), not the\n// rich capability/price inventory (that is F017 src/catalogue). We only track\n// ids we want to assert status on; anything not here is fail-open (treated\n// available) so we never block a model we simply do not track.\nimport { DEFAULT_TIER_MAP } from \"../routing/tier-map.js\";\nimport type { AvailabilityStatus, AvailabilitySource, ModelStatus } from \"./types.js\";\n\n/** Internal registry row. `aliases[0]` surfaces as ModelStatus.alias. */\nexport interface RegistryEntry {\n  id: string;\n  aliases: string[];\n  provider: string;\n  available: boolean;\n  status: AvailabilityStatus;\n  note?: string;\n  source: AvailabilitySource;\n}\n\nconst SUSPENDED_FABLE_MYTHOS = \"suspended — US export-control directive (2026-06-12)\";\n\n/** Curated defaults. Aliases here are MODEL-IDENTITY names only (short names for\n *  the model itself). TIER aliases — fast/smart/powerful/cheap/vision/video/\n *  embedding — are NOT written here: they are derived from DEFAULT_TIER_MAP below,\n *  because hand-maintaining them in two places is exactly how they drifted.\n *\n *  They HAD drifted, and it crossed the EU border: this list said `smart` was\n *  claude-sonnet-4-6 (Anthropic, US) for the ~3 months after F030 pointed the\n *  default tiers at Mistral EU, so resolveModel('smart') named a US model while\n *  ai.chat({tier:'smart'}) called an EU one. Anyone using resolveModel to SHOW or\n *  DECIDE where data goes — the obvious use — got the wrong answer. Measured by\n *  fd-sundhed in 0.21.1, still true in 0.28.0, fixed here by deleting the second\n *  list rather than correcting it. */\nconst DEFAULTS: RegistryEntry[] = [\n  // ── Anthropic ────────────────────────────────────────────────────────────\n  { id: \"claude-haiku-4-5\", aliases: [\"haiku\"], provider: \"anthropic\", available: true, status: \"available\", source: \"default\" },\n  { id: \"claude-sonnet-4-6\", aliases: [\"sonnet\"], provider: \"anthropic\", available: true, status: \"available\", source: \"default\" },\n  { id: \"claude-opus-4-8\", aliases: [\"opus\"], provider: \"anthropic\", available: true, status: \"available\", source: \"default\" },\n  { id: \"claude-fable-5\", aliases: [\"fable\"], provider: \"anthropic\", available: true, status: \"available\", source: \"default\" },\n  { id: \"claude-mythos-5\", aliases: [\"mythos\"], provider: \"anthropic\", available: false, status: \"suspended\", note: SUSPENDED_FABLE_MYTHOS, source: \"default\" },\n  // ── Gemini ───────────────────────────────────────────────────────────────\n  { id: \"gemini-2.5-flash\", aliases: [\"gemini-flash\"], provider: \"gemini\", available: true, status: \"available\", source: \"default\" },\n  { id: \"gemini-2.5-flash-lite\", aliases: [\"gemini-flash-lite\"], provider: \"gemini\", available: true, status: \"available\", source: \"default\" },\n  // ── OpenAI ───────────────────────────────────────────────────────────────\n  { id: \"text-embedding-3-small\", aliases: [], provider: \"openai\", available: true, status: \"available\", source: \"default\" },\n  // ── Mistral (EU / GDPR) ──────────────────────────────────────────────────\n  { id: \"mistral-large-latest\", aliases: [\"mistral-large\"], provider: \"mistral\", available: true, status: \"available\", source: \"default\" },\n  { id: \"mistral-medium-latest\", aliases: [\"mistral-medium\"], provider: \"mistral\", available: true, status: \"available\", source: \"default\" },\n  { id: \"mistral-small-latest\", aliases: [\"mistral-small\"], provider: \"mistral\", available: true, status: \"available\", source: \"default\" },\n];\n\n/** Attach every tier name as an alias of the model that tier ACTUALLY calls.\n *  One source: DEFAULT_TIER_MAP decides, the registry follows. A tier whose model\n *  is not in the registry is left unaliased on purpose — resolveModel then reports\n *  status \"unknown\" (fail-open) instead of inventing a row, and the drift test\n *  catches it. */\nexport const TIER_ALIAS_CONFLICTS: string[] = [];\n\nfunction applyTierAliases(entries: RegistryEntry[]): RegistryEntry[] {\n  for (const [tier, spec] of Object.entries(DEFAULT_TIER_MAP)) {\n    const owner = entries.find((e) => e.id === spec.model && e.provider === spec.provider);\n    // A tier name hand-written on any OTHER row is the drift bug returning. It\n    // would resolve correctly TODAY only because seed() lets the last write win\n    // and the rows happen to be ordered favourably — reorder the array and the\n    // tier silently points at the wrong provider again. Record it so a test can\n    // fail on it, then strip it so runtime is right regardless.\n    for (const e of entries) {\n      if (e !== owner && e.aliases.includes(tier)) {\n        TIER_ALIAS_CONFLICTS.push(`${tier} is hand-declared on ${e.id} (${e.provider}) but tier ${tier} calls ${spec.model} (${spec.provider})`);\n        e.aliases = e.aliases.filter((a) => a !== tier);\n      }\n    }\n    if (owner && !owner.aliases.includes(tier)) owner.aliases.push(tier);\n  }\n  return entries;\n}\napplyTierAliases(DEFAULTS);\n\n/** The live overlay, keyed by canonical id. Seeded from DEFAULTS (deep-copied so\n *  resetting is clean). refreshAvailability() mutates this; resolve/listModels\n *  read it synchronously. */\nlet OVERLAY = new Map<string, RegistryEntry>();\n/** alias → canonical id, rebuilt whenever the overlay is seeded. */\nlet ALIAS_INDEX = new Map<string, string>();\n\nfunction seed(): void {\n  OVERLAY = new Map(DEFAULTS.map((e) => [e.id, { ...e, aliases: [...e.aliases] }]));\n  ALIAS_INDEX = new Map();\n  for (const e of DEFAULTS) for (const a of e.aliases) ALIAS_INDEX.set(a, e.id);\n}\nseed();\n\n/** Reset the overlay back to the curated defaults. For tests. */\nexport function resetRegistry(): void {\n  seed();\n}\n\n/** Canonical id for a model id OR alias; null when we track neither. */\nexport function canonicalId(requested: string): string | null {\n  if (OVERLAY.has(requested)) return requested;\n  return ALIAS_INDEX.get(requested) ?? null;\n}\n\n/** The current entry for an id/alias, or undefined when untracked (fail-open). */\nexport function getEntry(requested: string): RegistryEntry | undefined {\n  const id = canonicalId(requested);\n  return id ? OVERLAY.get(id) : undefined;\n}\n\n/** All tracked entries (optionally provider-scoped), as a public ModelStatus[]. */\nexport function allEntries(provider?: string): ModelStatus[] {\n  const rows: ModelStatus[] = [];\n  for (const e of OVERLAY.values()) {\n    if (provider && e.provider !== provider) continue;\n    rows.push({\n      id: e.id,\n      alias: e.aliases[0],\n      provider: e.provider,\n      available: e.available,\n      status: e.status,\n      note: e.note,\n      source: e.source,\n    });\n  }\n  return rows;\n}\n\n/** Provider-scoped canonical ids (for refresh reconciliation). */\nexport function providerIds(provider: string): string[] {\n  return [...OVERLAY.values()].filter((e) => e.provider === provider).map((e) => e.id);\n}\n\n/** Mark a tracked id available/suspended from a live refresh. No-op if untracked. */\nexport function setAvailability(id: string, available: boolean, note?: string): void {\n  const e = OVERLAY.get(id);\n  if (!e) return;\n  e.available = available;\n  e.status = available ? \"available\" : \"suspended\";\n  e.source = \"refresh\";\n  if (note !== undefined) e.note = note;\n  else if (available) e.note = undefined;\n}\n","// F022 — Model Availability Harness. Public types for the availability layer:\n// the shared status read (ModelStatus), the resolve result, and the structured\n// error a caller can flag on. The registry is the one source both the spawn /\n// call path (resolveModel) and UI pickers (listModels) read.\n\nexport type AvailabilityStatus = \"available\" | \"suspended\" | \"unknown\";\n\n/** Where a model's current availability came from: the curated default seed,\n *  or a live provider refresh (Anthropic GET /v1/models). */\nexport type AvailabilitySource = \"default\" | \"refresh\";\n\n/** One row of the shared status read — what a UI model-picker renders. */\nexport interface ModelStatus {\n  /** Canonical provider model id, e.g. \"claude-fable-5\". */\n  id: string;\n  /** Short/tier alias, e.g. \"fable\" (the first registered alias). */\n  alias?: string;\n  /** \"anthropic\" | \"openai\" | \"gemini\" | \"mistral\" | … */\n  provider: string;\n  available: boolean;\n  status: AvailabilityStatus;\n  /** Friendly reason, e.g. \"suspended — US export-control directive (2026-06-12)\". */\n  note?: string;\n  source: AvailabilitySource;\n}\n\n/** Result of resolveModel — the spawn / call path consumes this synchronously. */\nexport interface ResolveResult {\n  /** True when the requested model itself is available. */\n  ok: boolean;\n  /** The id to actually use: `requested` when ok, else the first available fallback. */\n  model: string;\n  /** What the caller asked for (id or alias, normalized to the canonical id). */\n  requested: string;\n  provider?: string;\n  /** True when `model` differs from `requested` because we fell back. */\n  fellBack: boolean;\n  status: AvailabilityStatus;\n  /** Why it degraded / why it is unavailable. */\n  reason?: string;\n}\n\n/** Thrown by resolveModel when the requested model is unavailable, no usable\n *  fallback exists, and the caller passed `throwIfUnavailable`. Callers flag on\n *  `.code === \"model_unavailable\"`. */\nexport class ModelUnavailableError extends Error {\n  readonly code = \"model_unavailable\";\n  readonly requested: string;\n  readonly provider?: string;\n  readonly note?: string;\n  constructor(requested: string, note?: string, provider?: string) {\n    super(`model \"${requested}\" is unavailable${note ? ` (${note})` : \"\"}`);\n    this.name = \"ModelUnavailableError\";\n    this.requested = requested;\n    this.note = note;\n    this.provider = provider;\n  }\n}\n","// F022 — the synchronous, zero-I/O resolve + status read. This is the spawn /\n// call hot path (buddy's launcher calls resolveModel per spawn, cardmem #4842):\n// it MUST never await and never touch the network. Freshness comes only from a\n// prior async refreshAvailability(); resolve just reads the in-memory registry.\nimport { allEntries, canonicalId, getEntry } from \"./registry.js\";\nimport { ModelUnavailableError } from \"./types.js\";\nimport type { ModelStatus, ResolveResult } from \"./types.js\";\n\nexport interface ResolveOptions {\n  /** One id/alias or an ordered chain to try when `requested` is unavailable. */\n  fallback?: string | string[];\n  /** Scope hint (passed through to the result); does not gate lookup. */\n  provider?: string;\n  /** Throw ModelUnavailableError instead of returning ok:false when there is no\n   *  usable fallback. For callers that want to flag rather than degrade. */\n  throwIfUnavailable?: boolean;\n  /** Treat an id we do not track as UNUSABLE instead of fail-open.\n   *\n   *  Default is fail-open: we never block a model we simply do not track. That is\n   *  right for liveness, and wrong for a caller who is GATING — cms measured the\n   *  consequence: resolveModel(\"cheap\") answered {ok:true, model:\"cheap\"}, so a\n   *  consumer following our own instruction to gate on `ok` passed the gate and\n   *  then sent the literal string \"cheap\" to a provider as a model id. A\n   *  success-shaped non-answer is worse than an error, because an error gets\n   *  handled and a shape does not.\n   *\n   *  Set this when you need \"a model you actually know about\". Off by default so\n   *  no existing caller changes behaviour. */\n  requireKnown?: boolean;\n}\n\n/** The shared status read — UI pickers grey out `available:false` rows. */\nexport function listModels(opts: { provider?: string } = {}): ModelStatus[] {\n  return allEntries(opts.provider);\n}\n\n/** Is this id/alias currently usable? Untracked ids are fail-open (true) unless\n *  the caller asked for requireKnown. */\nfunction isAvailable(requested: string, requireKnown = false): boolean {\n  const e = getEntry(requested);\n  if (!e) return !requireKnown; // fail-open on unknown, unless gating\n  return e.available;\n}\n\n/**\n * Resolve a requested model (id or alias) to one that is actually usable.\n * Synchronous + offline by contract (cardmem #4842) — reads the registry only.\n *\n * - Available → pass through ({ ok:true, fellBack:false }).\n * - Unavailable + a fallback that IS available → swap ({ ok:false, fellBack:true }).\n * - Unavailable + no usable fallback → throw (throwIfUnavailable) or return ok:false.\n * - Unknown id → treated available (never block a model we do not track).\n */\nexport function resolveModel(requested: string, opts: ResolveOptions = {}): ResolveResult {\n  const id = canonicalId(requested) ?? requested;\n  const entry = getEntry(requested);\n  const provider = opts.provider ?? entry?.provider;\n\n  if (isAvailable(requested, opts.requireKnown)) {\n    return {\n      ok: true,\n      model: id,\n      requested: id,\n      provider,\n      fellBack: false,\n      status: entry?.status ?? \"unknown\",\n    };\n  }\n\n  // Requested is suspended — walk the fallback chain for the first available one.\n  const chain = opts.fallback === undefined ? [] : Array.isArray(opts.fallback) ? opts.fallback : [opts.fallback];\n  for (const fb of chain) {\n    if (isAvailable(fb, opts.requireKnown)) {\n      const fbId = canonicalId(fb) ?? fb;\n      return {\n        ok: false,\n        model: fbId,\n        requested: id,\n        provider,\n        fellBack: true,\n        status: entry?.status ?? \"suspended\",\n        reason: entry?.note ?? `${id} is unavailable`,\n      };\n    }\n  }\n\n  // No usable fallback.\n  const unknownAndGating = !entry && opts.requireKnown;\n  const reason = unknownAndGating\n    ? `${id} is not a model this registry knows — requireKnown was set, so it is not assumed usable`\n    : (entry?.note ?? `${id} is unavailable`);\n  if (opts.throwIfUnavailable) {\n    throw new ModelUnavailableError(id, reason, provider);\n  }\n  return {\n    ok: false,\n    model: id,\n    requested: id,\n    provider,\n    fellBack: false,\n    status: entry?.status ?? \"unknown\",\n    reason,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -1,6 +1,21 @@
 import { z } from 'zod';
 export { AvailabilitySource, AvailabilityStatus, ModelStatus, ModelUnavailableError, ResolveOptions, ResolveResult, listModels, resolveModel } from './registry.js';
 
+/** Coarse data-residency of the endpoint a call went to.
+ *
+ *  - `"eu"`  — EU/EEA. **The only positive residency claim.** Nothing else is folded
+ *              in: an adequacy decision is not EU residency, so the UK, Switzerland
+ *              and Canada are deliberately NOT `"eu"` here.
+ *  - `"us"`  — United States.
+ *  - `"cn"`  — China.
+ *  - `"unknown"` — we genuinely cannot say: an aggregator that picks its own upstream,
+ *              or a region string we do not recognise.
+ *
+ *  **`"unknown"` is NOT a synonym for safe.** `region !== "us"` is not an EU check —
+ *  it passes every OpenRouter call. Only `region === "eu"` may be treated as EU-resident.
+ */
+type Region = "eu" | "us" | "cn" | "unknown";
+
 /** How a call reaches the model. `http` = provider REST API; `subprocess` = local
  *  `claude -p` CLI (Max plan, costUsd 0). */
 type Transport = "http" | "subprocess";
@@ -32,8 +47,9 @@ type ContentPart = {
 interface Message {
     role: Role;
     content: string | ContentPart[];
-    /** Set on assistant messages that called tools. */
-    toolCalls?: ToolCall[];
+    /** Set on assistant messages that called tools. Accepts either spelling of the
+     *  arguments field — see ToolCallLike. */
+    toolCalls?: ToolCallLike[];
     /** Set on `tool` role messages — which call this result answers. */
     toolCallId?: string;
 }
@@ -44,12 +60,31 @@ interface Tool {
     description: string;
     parameters: Record<string, unknown>;
 }
-/** A model's request to invoke a tool, normalized across providers (F4.5). */
+/** A model's request to invoke a tool, normalized across providers (F4.5).
+ *  This is what we EMIT — `arguments` is always present on a ToolCall we return. */
 interface ToolCall {
     id: string;
     name: string;
     arguments: Record<string, unknown>;
 }
+/** What we ACCEPT when a tool call is handed BACK to us in a message history.
+ *
+ *  F043. `@broberg/chat` spells the same field `args`, consistently across its
+ *  ModelEvent / ChatFrame / ChatTool.run. Two packages describing the same thing
+ *  with two names cost cms a production outage: a rename living in a workaround was
+ *  deleted along with the workaround, and the next call failed with
+ *  `messages.1.toolCalls.0.arguments — Required`.
+ *
+ *  So we read both and keep emitting `arguments`. Accepting is cheap and cannot
+ *  break anyone; renaming would have broken a consumer who adopted the same day, and
+ *  asking every consumer that bridges the two packages to remember a translation is
+ *  how this happens again. Precedence is `arguments` when both are set. */
+type ToolCallLike = {
+    id: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+};
 /** Per-call usage. Fields mirror the upmetrics `agent_runs` schema 1:1 so the
  *  upmetricsSink (F3.7) forwards without re-mapping. `costUsd` is 0 for
  *  subprocess (Max plan); `subprocess:true` lets dashboards split free vs paid. */
@@ -57,6 +92,14 @@ interface Usage {
     provider: string;
     model: string;
     tier?: Tier;
+    /** Data-residency of the endpoint that ACTUALLY answered (F042). Derived from the
+     *  host/region the request used, not from the provider's name — vertex, azure and
+     *  bfl are EU by default but a consumer can point them elsewhere.
+     *
+     *  **Only `"eu"` is a positive residency claim.** `"unknown"` means we cannot say
+     *  (an aggregator picked its own upstream, or the region string is one we do not
+     *  recognise) — it is NOT a synonym for safe, so `region !== "us"` is not an EU check. */
+    region: Region;
     transport: Transport;
     inputTokens: number;
     outputTokens: number;
@@ -2103,8 +2146,8 @@ declare const falStubAdapter: ProviderAdapter;
  *  wires the live adapters. */
 declare const stubProviders: Record<string, ProviderAdapter>;
 
-declare const VERSION: "0.33.0";
-declare const SDK_TAG: "@broberg/ai-sdk@0.33.0";
+declare const VERSION: "0.35.0";
+declare const SDK_TAG: "@broberg/ai-sdk@0.35.0";
 
 /** Built-in defaults. Every entry is overridable via AiConfig.defaults or a
  *  per-call override.
@@ -2125,7 +2168,7 @@ declare const DEFAULT_TIER_MAP: Record<Tier, TierSpec>;
  * - `configMap` is the client-level AiConfig.defaults (per-tier full specs).
  * - `override` is a per-call Partial<TierSpec> — only the fields it sets win.
  */
-declare function resolveTier(tier: Tier, override?: Partial<TierSpec>, configMap?: Partial<Record<Tier, TierSpec>>): TierSpec;
+declare function resolveTier(tier: Tier, override?: Partial<TierSpec>, configMap?: Partial<Record<Tier, TierSpec>>, knownProviders?: readonly string[]): TierSpec;
 
 interface RefreshOptions {
     /** Only "anthropic" is wired in v1 (where the incident hit). */
@@ -2257,6 +2300,11 @@ declare function freshUsage(args: {
     outputTokens: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+    /** Data residency of the endpoint this call ACTUALLY used (F042). Pass it from any
+     *  adapter whose region a consumer can change — vertex, azure, bfl. Omitting it
+     *  falls back to the fixed provider table, which does not list those three, so a
+     *  forgetful adapter degrades to "unknown" rather than to a false "eu". */
+    region?: Region;
     subprocess?: boolean;
 }): Usage;
 

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   resolveModel,
   resolveTier,
   setAvailability
-} from "./chunk-V2PD522L.js";
+} from "./chunk-Y3EMGZFH.js";
 import {
   getPrice
 } from "./chunk-TENEIW7I.js";
@@ -26,6 +26,15 @@ async function httpTransport(req) {
   const json = await res.json().catch(() => void 0);
   return { ok: res.ok, status: res.status, json };
 }
+function errorBody(json, fallback = "(no body)") {
+  if (json === void 0 || json === null) return fallback;
+  if (typeof json === "string") return json.slice(0, 300);
+  try {
+    return (JSON.stringify(json) ?? fallback).slice(0, 300);
+  } catch {
+    return fallback;
+  }
+}
 
 // src/transport/subprocess.ts
 function parseClaudeCliJson(raw) {
@@ -202,6 +211,74 @@ function parseArgs(raw) {
   }
   return {};
 }
+function toolCallArgs(tc) {
+  return tc.arguments ?? tc.args ?? {};
+}
+
+// src/cost/region.ts
+var FIXED_PROVIDER_REGION = {
+  // api.mistral.ai — Paris. The designated EU/GDPR route for personal data.
+  mistral: "eu",
+  // api.deepl.com / api-free.deepl.com — EU-hosted (Falun, Sweden).
+  deepl: "eu",
+  openai: "us",
+  anthropic: "us",
+  // generativelanguage.googleapis.com is Google's GLOBAL endpoint, not a US-pinned one.
+  // We report "us" rather than "unknown" because it is certainly not EU-resident, and
+  // the honest error direction for a residency field is away from an EU claim. Vertex
+  // (below, region-pinned) is the route to use when EU residency is required.
+  gemini: "us",
+  deepinfra: "us",
+  fal: "us",
+  elevenlabs: "us",
+  // api.deepseek.com — People's Republic of China. No EU adequacy decision at all,
+  // which is a materially different position from the US, hence its own value.
+  deepseek: "cn",
+  // Aggregators: they choose the upstream provider per request, so the region is not
+  // ours to know. Reporting anything else here would be inventing a fact.
+  openrouter: "unknown",
+  requesty: "unknown"
+};
+var EU_REGION_NAMES = /* @__PURE__ */ new Set([
+  // Azure
+  "westeurope",
+  "northeurope",
+  "swedencentral",
+  "francecentral",
+  "francesouth",
+  "germanywestcentral",
+  "germanynorth",
+  "norwayeast",
+  "norwaywest",
+  "polandcentral",
+  "italynorth",
+  "spaincentral"
+]);
+var US_REGION_NAMES = /* @__PURE__ */ new Set([
+  // Azure
+  "eastus",
+  "eastus2",
+  "westus",
+  "westus2",
+  "westus3",
+  "centralus",
+  "northcentralus",
+  "southcentralus",
+  "westcentralus"
+]);
+function classifyRegionName(name) {
+  if (!name) return "unknown";
+  const n = name.trim().toLowerCase();
+  if (!n) return "unknown";
+  if (n.startsWith("europe-")) return "eu";
+  if (n.startsWith("us-")) return "us";
+  if (EU_REGION_NAMES.has(n)) return "eu";
+  if (US_REGION_NAMES.has(n)) return "us";
+  return "unknown";
+}
+function regionOfProvider(provider) {
+  return FIXED_PROVIDER_REGION[provider] ?? "unknown";
+}
 
 // src/cost/usage.ts
 function computeCost(provider, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheCreationTokens = 0) {
@@ -228,6 +305,7 @@ function freshUsage(args) {
   const usage = {
     provider: args.provider,
     model: args.model,
+    region: args.region ?? regionOfProvider(args.provider),
     transport: args.transport,
     inputTokens: args.inputTokens,
     outputTokens: args.outputTokens,
@@ -302,7 +380,7 @@ function anthropicAdapter(config = {}) {
           blocks.push(...contentBlocks(m.content));
         }
         for (const tc of m.toolCalls) {
-          blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
+          blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input: toolCallArgs(tc) });
         }
         messages.push({ role: "assistant", content: blocks });
         continue;
@@ -340,7 +418,7 @@ function anthropicAdapter(config = {}) {
         body
       }
     });
-    if (!res.ok) throw new Error(`anthropic ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    if (!res.ok) throw new Error(`anthropic ${res.status}: ${errorBody(res.json)}`);
     const data = res.json;
     const blocks = data.content ?? [];
     const text = blocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
@@ -503,7 +581,7 @@ function toOpenAIMessage(m) {
       base.tool_calls = m.toolCalls.map((tc) => ({
         id: tc.id,
         type: "function",
-        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+        function: { name: tc.name, arguments: JSON.stringify(toolCallArgs(tc)) }
       }));
     }
     return base;
@@ -519,25 +597,29 @@ function toOpenAIMessage(m) {
   });
   return { role: m.role, content };
 }
+function buildChatBody(req, config) {
+  const body = {
+    model: req.spec.model,
+    messages: req.messages.map(toOpenAIMessage)
+  };
+  if (req.tools) body.tools = toProviderTools(req.tools, "openai");
+  if (req.maxTokens !== void 0) body.max_tokens = req.maxTokens;
+  if (req.temperature !== void 0) body.temperature = req.temperature;
+  if (req.responseFormat === "json") body.response_format = { type: "json_object" };
+  if (config.supportsPromptCacheKey && req.promptCache !== false) {
+    const k = req.promptCacheKey ?? autoCacheKey(req.messages);
+    if (k !== void 0) body.prompt_cache_key = k;
+  }
+  if (config.costFromResponseField) body.usage = { include: true };
+  return body;
+}
 function makeOpenAICompatibleAdapter(config) {
   async function chat(req) {
     const apiKey = config.apiKey ?? process.env[`${config.name.toUpperCase()}_API_KEY`];
     if (!apiKey) {
       throw new Error(`${config.name} adapter: API key not set (env ${config.name.toUpperCase()}_API_KEY)`);
     }
-    const body = {
-      model: req.spec.model,
-      messages: req.messages.map(toOpenAIMessage)
-    };
-    if (req.tools) body.tools = toProviderTools(req.tools, "openai");
-    if (req.maxTokens !== void 0) body.max_tokens = req.maxTokens;
-    if (req.temperature !== void 0) body.temperature = req.temperature;
-    if (req.responseFormat === "json") body.response_format = { type: "json_object" };
-    if (config.supportsPromptCacheKey && req.promptCache !== false) {
-      const k = req.promptCacheKey ?? autoCacheKey(req.messages);
-      if (k !== void 0) body.prompt_cache_key = k;
-    }
-    if (config.costFromResponseField) body.usage = { include: true };
+    const body = buildChatBody(req, config);
     const res = await httpTransport({
       spec: req.spec,
       http: {
@@ -551,7 +633,7 @@ function makeOpenAICompatibleAdapter(config) {
       }
     });
     if (!res.ok) {
-      throw new Error(`${config.name} ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+      throw new Error(`${config.name} ${res.status}: ${errorBody(res.json)}`);
     }
     const data = res.json;
     const msg = data.choices?.[0]?.message;
@@ -586,16 +668,10 @@ function makeOpenAICompatibleAdapter(config) {
       throw new Error(`${config.name} adapter: API key not set (env ${config.name.toUpperCase()}_API_KEY)`);
     }
     const body = {
-      model: req.spec.model,
-      messages: req.messages.map(toOpenAIMessage),
+      ...buildChatBody(req, config),
       stream: true,
       stream_options: { include_usage: true }
     };
-    if (req.tools) body.tools = toProviderTools(req.tools, "openai");
-    if (req.maxTokens !== void 0) body.max_tokens = req.maxTokens;
-    if (req.temperature !== void 0) body.temperature = req.temperature;
-    if (req.responseFormat === "json") body.response_format = { type: "json_object" };
-    if (config.costFromResponseField) body.usage = { include: true };
     const stream = streamTransport({
       spec: req.spec,
       fetch: config.fetch,
@@ -711,7 +787,7 @@ function openaiAdapter(config = {}) {
       }
     });
     if (!res.ok) {
-      throw new Error(`openai ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+      throw new Error(`openai ${res.status}: ${errorBody(res.json)}`);
     }
     const data = res.json;
     const vectors = (data.data ?? []).map((d) => d.embedding);
@@ -876,7 +952,7 @@ function geminiAdapter(config = {}) {
       }
     });
     if (!res.ok) {
-      throw new Error(`gemini ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+      throw new Error(`gemini ${res.status}: ${errorBody(res.json)}`);
     }
     const data = res.json;
     const parts = data.candidates?.[0]?.content?.parts ?? [];
@@ -1480,6 +1556,9 @@ function azureAdapter(config = {}) {
     const usage = freshUsage({
       provider: "azure",
       model,
+      // Same region() that picked the host. westeurope by default, but
+      // config.region / AZURE_SPEECH_REGION can point this at eastus.
+      region: classifyRegionName(region()),
       transport: "http",
       capability: "tts",
       inputTokens: 0,
@@ -1540,6 +1619,7 @@ function azureAdapter(config = {}) {
     const usage = freshUsage({
       provider: "azure",
       model: req.spec.model,
+      region: classifyRegionName(region()),
       transport: "http",
       capability: "transcribe",
       inputTokens: 0,
@@ -1713,6 +1793,10 @@ function vertexAdapter(config = {}) {
     const usage = freshUsage({
       provider: "vertex",
       model: req.spec.model,
+      // Read from the SAME region() that built the URL above — this adapter is EU by
+      // default, but config.region / GOOGLE_VERTEX_REGION can move it, and a residency
+      // field that ignores the override is worse than none.
+      region: classifyRegionName(region()),
       transport: "http",
       capability: "animate",
       inputTokens: 0,
@@ -1754,6 +1838,10 @@ function vertexAdapter(config = {}) {
     const usage = freshUsage({
       provider: "vertex",
       model: req.spec.model,
+      // Read from the SAME region() that built the URL above — this adapter is EU by
+      // default, but config.region / GOOGLE_VERTEX_REGION can move it, and a residency
+      // field that ignores the override is worse than none.
+      region: classifyRegionName(region()),
       transport: "http",
       capability: "vision",
       inputTokens,
@@ -2145,6 +2233,13 @@ async function bflCredits(opts = {}) {
   const credits = typeof data.credits === "number" ? data.credits : 0;
   return { credits, usd: credits * BFL_CREDIT_USD };
 }
+function bflRegion(base) {
+  try {
+    return new URL(base).host.toLowerCase() === "api.eu.bfl.ai" ? "eu" : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 function bflAdapter(config = {}) {
   const doFetch = config.fetch ?? fetch;
   const base = config.baseUrl ?? EU_BASE2;
@@ -2191,6 +2286,7 @@ function bflAdapter(config = {}) {
     const usage = freshUsage({
       provider: "bfl",
       model: req.spec.model,
+      region: bflRegion(base),
       transport: "http",
       capability: "image",
       inputTokens: 0,
@@ -2822,8 +2918,8 @@ var aiConfigSchema = z.object({
 });
 
 // src/version.ts
-var VERSION = "0.33.0";
-var SDK_TAG = "@broberg/ai-sdk@0.33.0";
+var VERSION = "0.35.0";
+var SDK_TAG = "@broberg/ai-sdk@0.35.0";
 
 // src/cost/sinks/upmetrics.ts
 function upmetricsSink(config) {
@@ -2953,6 +3049,7 @@ function createAI(config = {}) {
   async function settle(usage) {
     if (budget) await budget.record(usage.costUsd);
   }
+  const providerNames = Object.keys(providers);
   function pickProvider(name) {
     const adapter = providers[name];
     if (!adapter) {
@@ -3043,7 +3140,7 @@ function createAI(config = {}) {
     );
     const estOut = input.maxTokens ?? 512;
     const routes = [
-      resolveTier(tier, input.override, cfg.defaults),
+      resolveTier(tier, input.override, cfg.defaults, providerNames),
       ...(input.fallback ?? []).map(
         (f) => typeof f === "string" ? resolveTier(f, void 0, cfg.defaults) : f
       )
@@ -3065,7 +3162,13 @@ function createAI(config = {}) {
           tools: input.tools,
           maxTokens: input.maxTokens,
           temperature: input.temperature,
-          responseFormat: input.responseFormat
+          responseFormat: input.responseFormat,
+          // F043: these two were dropped here, so a streamed call could not cache even
+          // after the adapter learned how. A chat UI streams every turn and repeats the
+          // same system prompt each time — the call shape with the most to gain was the
+          // one paying full price. Kept identical to the chat branch above on purpose.
+          promptCacheKey: input.promptCacheKey,
+          promptCache: input.promptCache ?? cfg.promptCache
         })) {
           if (ev.type === "text" || ev.type === "tool_call") emitted = true;
           if (ev.type === "usage") {
@@ -3096,7 +3199,7 @@ function createAI(config = {}) {
         0
       );
       return runCapability({
-        primary: resolveTier(tier, input.override, cfg.defaults),
+        primary: resolveTier(tier, input.override, cfg.defaults, providerNames),
         fallback: input.fallback,
         capability: "chat",
         tier,
@@ -3117,7 +3220,7 @@ function createAI(config = {}) {
       const tier = input.tier ?? VISION_DEFAULT_TIER;
       const messages = buildVisionMessages(input);
       return runCapability({
-        primary: resolveTier(tier, input.override, cfg.defaults),
+        primary: resolveTier(tier, input.override, cfg.defaults, providerNames),
         fallback: input.fallback,
         capability: "vision",
         tier,
@@ -3138,7 +3241,7 @@ function createAI(config = {}) {
       const tier = input.tier ?? VIDEO_DEFAULT_TIER;
       const messages = buildVideoMessages(input);
       return runCapability({
-        primary: resolveTier(tier, input.override, cfg.defaults),
+        primary: resolveTier(tier, input.override, cfg.defaults, providerNames),
         fallback: input.fallback,
         capability: "video",
         tier,
@@ -3160,7 +3263,7 @@ function createAI(config = {}) {
       const messages = buildTranslateMessages(input);
       const estIn = estTokens(input.text) + 40;
       const res = await runCapability({
-        primary: resolveTier(tier, input.override, cfg.defaults),
+        primary: resolveTier(tier, input.override, cfg.defaults, providerNames),
         fallback: input.fallback,
         capability: "translate",
         tier,
@@ -3350,7 +3453,7 @@ function createAI(config = {}) {
       const tier = input.tier ?? EMBEDDING_DEFAULT_TIER;
       const text = Array.isArray(input.text) ? input.text : [input.text];
       return runCapability({
-        primary: resolveTier(tier, input.override, cfg.defaults),
+        primary: resolveTier(tier, input.override, cfg.defaults, providerNames),
         fallback: input.fallback,
         capability: "embedding",
         tier,
@@ -3416,6 +3519,9 @@ function stubUsage(provider, model, transport, capability) {
   return {
     provider,
     model,
+    // Stubs answer no network, so there is no endpoint whose residency we could
+    // report. "unknown" is the truthful reading — not a placeholder "eu".
+    region: "unknown",
     transport,
     inputTokens: 0,
     outputTokens: 0,