@genesislcap/foundation-ai 15.11.0 → 15.12.0

package/dist/foundation-ai.d.ts

@@ -36,13 +36,26 @@ export declare type AgentPickerMode = 'disabled' | 'select' | 'segmented-control
  * @beta
  */
 export declare interface AggregateUsage {
-    /** USD cost, provider-reported per request and summed — cache discounts applied. */
+    /**
+     * USD cost, provider-reported per request and summed — cache discounts applied.
+     *
+     * The authoritative total. It is a **sum of per-request costs**, each computed where
+     * the full provider usage was in hand; it is never re-derived from the token buckets
+     * below, and should not be.
+     */
     costUsd: number;
     /** Prompt tokens billed at the full uncached input rate. */
     uncachedInputTokens: number;
     /** Prompt tokens served from the provider's cache. */
     cacheReadTokens: number;
-    /** Prompt tokens written to the provider's cache. */
+    /**
+     * Prompt tokens written to the provider's cache.
+     *
+     * **Volume only — this aggregate can never be priced.** Two reasons, either of which
+     * is sufficient: Anthropic's per-TTL write split is already collapsed on each
+     * contributing message, and a run may span models (and providers) at different rates,
+     * so no single rate applies to the total. Report it, chart it, do not multiply it.
+     */
     cacheWriteTokens: number;
     /** Generated (output) tokens, including any reasoning tokens the provider bills as output. */
     outputTokens: number;
@@ -227,6 +240,23 @@ declare interface AITransport {
     isAvailable?(): Promise<boolean>;
 }
 
+/**
+ * Prompt-cache pricing multipliers, applied to the model's base input rate
+ * (`promptPerMillion`) — https://docs.claude.com/en/docs/build-with-claude/prompt-caching
+ * Reads bill at ~0.1× base input; writes bill by TTL — 5-minute at ~1.25× and 1-hour at 2×.
+ * Both write TTLs are reachable (`CachePolicy.ttl` is `'5m' | '1h'`), so each TTL bucket is
+ * costed from the response's per-TTL `cache_creation` breakdown rather than assuming one rate.
+ *
+ * @beta
+ */
+export declare const ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
+
+/** @beta */
+export declare const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+
+/** @beta */
+export declare const ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER = 1.25;
+
 /**
  * Anthropic server-proxy AI configuration (client calls your server; server calls Anthropic).
  *
@@ -279,6 +309,29 @@ declare interface AnthropicProviderConfig {
     criteriaInstructions?: string;
 }
 
+/**
+ * Standard tier pricing per million tokens —
+ * https://docs.claude.com/en/docs/about-claude/pricing
+ *
+ * @remarks
+ * Backed by a total {@link https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type | Record}
+ * over `AnthropicModelId` rather than a chain of checks with a default. That is the whole
+ * point: adding a model to `SUPPORTED_ANTHROPIC_MODEL_IDS` without pricing it becomes a
+ * COMPILE error instead of a silent charge at whatever the fall-through happened to be — the
+ * exact failure this module's header warns about, and one a consumer has already been bitten
+ * by. The Gemini half of this file has always had the guarantee; this half now matches.
+ *
+ * @beta
+ */
+export declare function anthropicRatesFor(model: AnthropicModelId): TokenRates;
+
+/**
+ * Cost one Anthropic request.
+ *
+ * @beta
+ */
+export declare function anthropicTokenCost(model: AnthropicModelId, usage: AnthropicUsageRecord): TokenCost;
+
 /**
  * Transport for Anthropic Claude. Calls the Messages API directly when `apiKey`
  * is provided, otherwise falls back to a server-proxy endpoint (if `serverEndpoint`
@@ -309,6 +362,26 @@ export declare class AnthropicTransport implements AITransport, ChatTransport, C
      * accrue. Surfaced alongside `getLifetimeCost`.
      */
     private lifetimeSavingsUsd;
+    /**
+     * Whether we have already told the caller their `thinkingPolicy: 'off'` cannot be honoured
+     * on this model. Latched, because it would otherwise fire on every turn of a tool loop.
+     */
+    private warnedThinkingClamped;
+    /**
+     * Serving-model ids already reported as unrecognised. Per-id rather than a single flag, so a
+     * second unknown model is still announced. See {@link AnthropicTransport.servingModel}.
+     */
+    private readonly warnedUnknownServingModels;
+    /**
+     * Warn once when a requested policy is silently clamped, in EITHER direction — which is what
+     * `ChatThinkingPolicy` promises callers. Both directions cost the caller something they asked
+     * for and would otherwise get no signal about: `'off'` on a model that always thinks keeps
+     * billing reasoning as output, and `'auto'` on a model without adaptive support means an agent
+     * that asked to reason quietly does not. (Gemini's twin deliberately stays silent on `'auto'`,
+     * but only because dynamic thinking is already the default there; Haiku defaults to none, so
+     * the same silence would hide a real difference.)
+     */
+    private warnIfThinkingUnclampable;
     constructor(config?: AnthropicTransportConfig);
     getConfig(): {
         provider: 'anthropic';
@@ -364,6 +437,76 @@ export declare class AnthropicTransport implements AITransport, ChatTransport, C
      * the payload tidy.
      */
     private toAnthropicMessages;
+    /**
+     * The blocks to replay ahead of a tool call — fallback boundaries then reasoning, or none.
+     *
+     * A `signature` is only valid for the model that produced it, so reasoning captured under a
+     * *different* model is normally dropped: an agent that varies `provider` by state can switch
+     * models mid-loop, and replaying the old model's signatures would send blocks the new one
+     * cannot verify.
+     *
+     * Two ways the producer can be the model that will validate:
+     *
+     * 1. **It is the model we are asking for.** `state.model === this.model` — the ordinary case.
+     * 2. **Sticky routing will send this conversation back to it.** After a conversation falls
+     *    back, later requests carrying `fallbacks` go straight to the model that served, without
+     *    re-running the one that declined. That is what makes a fallback producer's reasoning
+     *    replayable at all (Fable 5 configured, Opus 4.8 serving — the pairing this transport's
+     *    own constructor warning recommends). But it holds only while the conversation continues
+     *    under the SAME request configuration, which is why `requestedModel` is compared rather
+     *    than just checking the chain for the producer.
+     *
+     * That second condition is deliberately narrow. Chain membership alone is too weak: a
+     * fallback target is only *contingently* the server, so an agent that switches `provider` to
+     * a model whose own chain happens to contain the old producer would replay foreign
+     * signatures to whichever model actually answers. Requiring the requested model to be
+     * unchanged separates "this conversation is still going" from "we are somewhere else now".
+     *
+     * State captured before `requestedModel` existed falls back to condition 1 alone, which is
+     * the conservative branch — it can drop reasoning, never misdirect it.
+     *
+     * Boundaries themselves are always echoed: keeping them in place is the documented rule, and
+     * with no thinking blocks around them they are inert rather than harmful.
+     */
+    private reasoningToReplay;
+    /**
+     * The model that actually served this response.
+     *
+     * A server-side `fallbacks` chain re-runs a declined request on another model and
+     * names it in the response's top-level `model`. Pricing must follow that, not the
+     * model we asked for: a Fable 5 request served by Opus 4.8 costed at Fable's
+     * $10/$50 instead of $5/$25 doubles that part of the bill.
+     *
+     * An unrecognised model id is NOT priced at a guessed rate — that is precisely how
+     * a consumer ended up billing Haiku at Sonnet rates. It warns and falls back to the
+     * configured model, which is at least a figure someone chose.
+     */
+    private servingModel;
+    /**
+     * Whether a fallback-chain attempt is a refusal that was **not billed**.
+     *
+     * Anthropic does not charge for a refusal that arrives before any output: the token counts
+     * still appear in `usage`, but they are not on the bill. Pricing them anyway turns the
+     * fallback undercount this reducer was written to fix into an overcount — the documented
+     * example declines with `input_tokens: 535, output_tokens: 0`, which is real money at
+     * Fable 5's prompt rate.
+     *
+     * A **mid-output** refusal *is* billed for the input and whatever it streamed, so output
+     * tokens are the discriminator rather than the refusal itself.
+     *
+     * Declined attempts appear as `type: 'message'`; the attempt that served the turn is
+     * `type: 'fallback_message'`. The serving entry is normally billable — except when every
+     * model in the chain declined, where the last entry is both the serving one and a refusal,
+     * which `lastAndRefused` covers.
+     *
+     * Also called for a response with no chain at all, as `isUnbilledRefusal({}, usage, refused)`:
+     * a direct request that was declined has no `iterations` array, and the same rule applies to
+     * it. That is in fact the common case — `iterations` only appears when `fallbacks` was
+     * configured.
+     */
+    private isUnbilledRefusal;
+    /** Cost one attempt's usage block at `model`'s rates, logging and banking it. */
+    private costAttempt;
     private fromAnthropicResponse;
     private buildEndpoint;
     private static readonly RATE_LIMIT_STATUS;
@@ -407,6 +550,38 @@ declare interface AnthropicTransportConfig {
     maxTokens?: number;
 }
 
+/**
+ * Token counts from an Anthropic `usage` block.
+ *
+ * @remarks
+ * Note the input semantics, which are the opposite of Gemini's: `input_tokens` on
+ * this provider is the **uncached remainder**, so the three input buckets ADD to
+ * the prompt total rather than breaking it down.
+ *
+ * @beta
+ */
+export declare interface AnthropicUsageRecord {
+    /** `usage.input_tokens` — the uncached remainder of the prompt, billed at full rate. */
+    uncachedInputTokens: number;
+    /** `usage.output_tokens`. Includes thinking tokens, which this provider bills as output. */
+    outputTokens: number;
+    /** `usage.cache_read_input_tokens`. */
+    cacheReadTokens: number;
+    /** `usage.cache_creation_input_tokens` — the total across BOTH TTLs. */
+    cacheWriteTokens: number;
+    /**
+     * `usage.cache_creation.ephemeral_1h_input_tokens` — the 1-hour portion of
+     * {@link AnthropicUsageRecord.cacheWriteTokens}. The remainder is treated as
+     * 5-minute, which is also the correct fallback when a response omits the
+     * per-TTL breakdown entirely.
+     *
+     * Pass `0` if unknown. Doing so under-bills a request that really did write to
+     * the 1-hour cache — by the difference between the two multipliers — so prefer
+     * reading the breakdown when the provider sends one.
+     */
+    cacheWrite1hTokens: number;
+}
+
 /**
  * The vendors whose spend the ai-service proxy meters — i.e. the only vendors
  * that can raise a {@link BudgetExhaustedError}, and therefore the only ones a
@@ -914,6 +1089,18 @@ export declare interface ChatMessage {
      * {@link ChatMessage.inputTokens} rather than an addition to it. `undefined`
      * where the provider reports no distinct write bucket (e.g. Gemini's implicit
      * caching) — read it with `?? 0`.
+     *
+     * **A volume figure, not a pricing input — do not re-price it.** Anthropic bills
+     * cache writes by TTL (5-minute and 1-hour at different multiples of the input
+     * rate) and this field is the combined total, so the split needed to cost it is
+     * not recoverable from a stored message. Pricing this bucket therefore under-bills
+     * a 1-hour write, silently and in the cheap direction. {@link ChatMessage.cost} is
+     * the authoritative figure: the transport computed it from the per-TTL breakdown
+     * before that breakdown was collapsed to this total.
+     *
+     * A host that genuinely must compute a cost itself — a proxy holding a raw provider
+     * usage block, where nothing stamped one — should price from that raw block instead,
+     * which carries the split.
      */
     cacheWriteTokens?: number;
     /**
@@ -921,6 +1108,25 @@ export declare interface ChatMessage {
      * derived from the active model's input/output rates. Set by transports.
      * Hosts can sum this across the message list to display a running session
      * cost without re-deriving rates.
+     *
+     * @remarks
+     * **The authoritative cost for this request.** Computed at the transport, at the
+     * one point where the full provider usage is in hand — including Anthropic's
+     * per-TTL cache-write breakdown, which the token fields on this message do not
+     * preserve. Prefer it over any figure re-derived from those fields, which cannot
+     * be exact and is wrong in the direction that under-reports spend.
+     *
+     * Already carries every cache discount and premium, so a cache-heavy request shows
+     * a small `cost` against a large token count — that is the discount working, not a
+     * missing charge.
+     *
+     * **When a server-side fallback chain ran, this and the token fields have different
+     * scopes.** `cost` sums every *billed* attempt, possibly across models at different
+     * rates, while `inputTokens` / `outputTokens` / the cache buckets describe only the
+     * attempt that produced the content. So such a turn can carry cost with no volume
+     * behind it to explain the difference — a $/token column or a "cost without tokens"
+     * audit will see an outlier that is correct. Read `cost` as the bill and the token
+     * fields as the size of the answer, not as two views of one thing.
      */
     cost?: number;
     /**
@@ -1043,6 +1249,14 @@ export declare interface ChatRequestOptions {
      * @beta
      */
     responseSchema?: object;
+    /**
+     * Extended-thinking posture for this turn. **Omit** to keep each model's own default —
+     * that is the third state, and it is not the same as either value. See
+     * {@link ChatThinkingPolicy}.
+     *
+     * @beta
+     */
+    thinkingPolicy?: ChatThinkingPolicy;
 }
 
 /**
@@ -1164,6 +1378,46 @@ export declare const ChatTemperature: {
     readonly Maximum: 1;
 };
 
+/**
+ * Whether the model should reason before answering, resolved per turn.
+ * **Provider-neutral intent, provider-specific effect**, and — like `tool_choice` — a
+ * *request*, not a guarantee: a model that cannot honour it keeps its default.
+ *
+ * - `'auto'` — the model decides how much to think (Anthropic `thinking: {type:'adaptive'}`,
+ *   Gemini `thinkingConfig.thinkingBudget: -1`). On a model whose default is thinking-*off*
+ *   this turns it **on**, which is the point: it is the opt-in for models where adaptive
+ *   thinking is available but not default.
+ * - `'off'` — no reasoning tokens (Anthropic `thinking: {type:'disabled'}`, Gemini
+ *   `thinkingBudget: 0`). The lever for turns that only step a known sequence, where reasoning
+ *   is billed as output at the full candidate rate to decide something already determined.
+ *
+ * **Choose it per turn, not per model call.** A tool-use loop is one assistant turn, and
+ * Anthropic requires a single thinking mode for its duration; toggling part-way through does
+ * not error but silently disables thinking for that request, strips blocks that would leave the
+ * turn structure invalid, and invalidates the prompt cache. The driver pins whatever it resolves
+ * on a turn's first model call for the rest of that turn.
+ *
+ * Deliberately has **no token-budget member**. Gemini accepts a numeric `thinkingBudget`, but
+ * Anthropic *removed* `budget_tokens` and returns a 400 for it on Sonnet 5 and every Opus 5-era
+ * model — so a budget field would be unimplementable on half the supported fleet and would exist
+ * only to be ignored. `'low' | 'high'` can be added later if wanted: Anthropic `effort` and
+ * Gemini `thinkingLevel` do line up.
+ *
+ * **Omitting this is a distinct third state** — each model keeps its own default posture
+ * (see `anthropicThinking`), which is *not* uniformly `'auto'` or `'off'`. So a resolver
+ * returning `undefined` on some turns leaves those turns exactly as they were before this
+ * option existed, rather than silently re-pricing them.
+ *
+ * Not every model can honour every value, and the two providers hit the same wall at the top
+ * of their ranges: Anthropic Fable 5 and Gemini 2.5 Pro both think unconditionally and reject
+ * (or ignore) a request to stop. Transports **clamp** rather than forward a request that would
+ * 400 — the turn runs at the model's default and a one-time warning is logged. Never assume
+ * `'off'` means zero reasoning tokens were billed; read the usage back.
+ *
+ * @beta
+ */
+export declare type ChatThinkingPolicy = 'auto' | 'off';
+
 /**
  * A tool call requested by the assistant.
  *
@@ -1774,6 +2028,27 @@ export declare type FieldLike = string | {
     NAME?: string;
 };
 
+/**
+ * Cached / context-cache input tokens bill at a flat ~10% of the model's normal input
+ * rate — consistent across models (flash $0.30→$0.03, flash-lite $0.10→$0.01,
+ * pro $1.25→$0.125). Source: https://ai.google.dev/gemini-api/docs/pricing.
+ * (Explicit context caching also has an hourly storage fee; implicit caching — what the
+ * transport relies on — has none, so only this read discount applies. There is no write
+ * premium on this provider, which is why its savings figure is never negative.)
+ *
+ * @beta
+ */
+export declare const GEMINI_CACHED_INPUT_MULTIPLIER = 0.1;
+
+/**
+ * Prompt size (tokens) at or below which the standard pricing tier applies.
+ * Above it, Gemini's long-context tier kicks in. Google applies a single tier
+ * to the whole request based on prompt size — it is not a marginal/blended rate.
+ *
+ * @beta
+ */
+export declare const GEMINI_LONG_CONTEXT_THRESHOLD = 200000;
+
 /**
  * Gemini server-proxy AI configuration (client calls your server; server calls Gemini).
  *
@@ -1818,6 +2093,30 @@ declare interface GeminiProviderConfig {
     criteriaInstructions?: string;
 }
 
+/**
+ * Resolve the per-million-token rates for a model given the request's prompt size,
+ * selecting the long-context tier for tiered models when the prompt exceeds
+ * {@link GEMINI_LONG_CONTEXT_THRESHOLD}.
+ *
+ * @remarks
+ * `promptTokens` must be the **full** prompt size, cached slice included — the tier
+ * is chosen on what was sent, not on what was billed at full rate. A mostly-cached
+ * long prompt is still a long prompt.
+ *
+ * Unlike Anthropic's, this accessor is not a pure function of the model, which is
+ * why there is no single `ratesFor(model)` across both providers.
+ *
+ * @beta
+ */
+export declare function geminiRatesFor(model: GeminiModelId, promptTokens: number): TokenRates;
+
+/**
+ * Cost one Gemini request.
+ *
+ * @beta
+ */
+export declare function geminiTokenCost(model: GeminiModelId, usage: GeminiUsageRecord): TokenCost;
+
 /**
  * Transport for Gemini. Calls the Gemini REST API directly when `apiKey` is
  * provided, otherwise falls back to a server-proxy endpoint (if `serverEndpoint`
@@ -1846,6 +2145,22 @@ export declare class GeminiTransport implements AITransport, ChatTransport, Cost
      * Surfaced alongside `getLifetimeCost`.
      */
     private lifetimeSavingsUsd;
+    /**
+     * Whether we have already told the caller their `thinkingPolicy` cannot be honoured on this
+     * model. Latched, because it would otherwise fire on every turn of a tool loop.
+     */
+    private warnedThinkingClamped;
+    /**
+     * Warn once when a requested policy is silently clamped. Turning thinking off is a *cost*
+     * decision, so a caller who asked for it and kept paying for reasoning tokens needs to hear
+     * about it — but only once, not per turn.
+     *
+     * Only `'off'` can actually be denied. `'auto'` is already what an omitted budget produces on
+     * every model here — dynamic thinking is the documented default — so warning that it was
+     * "ignored" would be false, and latching on it would spend the one warning the genuinely
+     * unhonourable `'off'` needs.
+     */
+    private warnIfThinkingUnclampable;
     constructor(config?: GeminiTransportConfig);
     getConfig(): {
         provider: 'gemini';
@@ -1953,6 +2268,31 @@ declare interface GeminiTransportConfig {
     serverEndpoint?: string;
 }
 
+/**
+ * Token counts from a Gemini `usageMetadata` block.
+ *
+ * @remarks
+ * Note the input semantics, which are the opposite of Anthropic's:
+ * `promptTokenCount` is the **whole** prompt and already includes
+ * `cachedContentTokenCount`, so uncached input is a subtraction. Adding the buckets
+ * instead double-charges the cached portion.
+ *
+ * @beta
+ */
+export declare interface GeminiUsageRecord {
+    /** `usageMetadata.promptTokenCount` — the whole prompt, cached slice INCLUDED. */
+    promptTokens: number;
+    /** `usageMetadata.candidatesTokenCount`. */
+    candidateTokens: number;
+    /**
+     * `usageMetadata.thoughtsTokenCount`. Reported separately from candidates but
+     * billed at the candidate rate, so omitting it undercounts the bill.
+     */
+    thoughtTokens: number;
+    /** `usageMetadata.cachedContentTokenCount` — 0 when caching was not active. */
+    cachedTokens: number;
+}
+
 /**
  * How the host frames an interaction widget in the chat transcript. The
  * assistant avatar is always shown; this controls only the bubble and the
@@ -2500,6 +2840,69 @@ export declare const SUPPORTED_ANTHROPIC_MODEL_IDS: readonly AnthropicModelId[];
 /** @beta */
 export declare const SUPPORTED_GEMINI_MODEL_IDS: readonly GeminiModelId[];
 
+/**
+ * What one request cost, and what prompt caching saved on it.
+ *
+ * @beta
+ */
+export declare interface TokenCost {
+    /** Total USD for the request, with every cache discount and premium applied. */
+    costUsd: number;
+    /**
+     * USD saved versus paying the full input rate for every cached token, net of any
+     * cache-write premium.
+     *
+     * **Can be negative**, and that is not an error: a write premium is an upfront
+     * cost that later reads pay back, so a cold write-heavy request legitimately
+     * reports a loss. Clamping it at zero destroys the signal that a cache is being
+     * written more often than it is read.
+     */
+    savedUsd: number;
+    /**
+     * The four cost buckets, summing to {@link TokenCost.costUsd}.
+     *
+     * Reported because a single total cannot show *why* a request was cheap: a
+     * cache-heavy call moves a large number of tokens for very little money, and only
+     * the split says so. Also what a per-call usage row needs, rather than the one
+     * number a dashboard would have to explain.
+     */
+    breakdown: TokenCostBreakdown;
+}
+
+/**
+ * Per-bucket cost split for one request. Each field is already in USD.
+ *
+ * @beta
+ */
+export declare interface TokenCostBreakdown {
+    /** Prompt tokens billed at the full uncached input rate. */
+    promptUsd: number;
+    /** Prompt tokens served from the provider's cache. */
+    cacheReadUsd: number;
+    /**
+     * Prompt tokens written to the provider's cache. Always `0` on Gemini, whose
+     * implicit caching has no write charge.
+     *
+     * A per-request charge for *populating* a cache. Not a home for a cache's ongoing
+     * storage cost, which is not per-request — see the module header.
+     */
+    cacheWriteUsd: number;
+    /** Generated output, including any reasoning tokens billed as output. */
+    candidateUsd: number;
+}
+
+/**
+ * USD per million tokens, split by direction. `prompt` covers input/prompt tokens,
+ * `candidate` covers generated output (including any reasoning tokens the provider
+ * bills as output).
+ *
+ * @beta
+ */
+export declare interface TokenRates {
+    promptPerMillion: number;
+    candidatePerMillion: number;
+}
+
 /**
  * Why a driver turn ended in failure — the typed taxonomy the tool loop already
  * records onto its debug-log timeline (`turn.error` / `turn.retry` details),
@@ -2562,6 +2965,33 @@ export declare type TurnFailureReason = 'exception' | 'malformed-function-call'
  */
 export declare const VENDOR_LABELS: Readonly<Record<Exclude<AIProviderType, 'none'>, string>>;
 
+/**
+ * Which vendor a model id belongs to, or `undefined` when no supported provider claims it.
+ *
+ * @remarks
+ * Derived from {@link SUPPORTED_ANTHROPIC_MODEL_IDS} and {@link SUPPORTED_GEMINI_MODEL_IDS},
+ * so it cannot drift from them the way a hand-maintained map does — adding a model to an
+ * allowlist is enough to teach this too.
+ *
+ * Exists because callers hold a **model id**, not a vendor. A usage ledger reads a message's
+ * `model` and then has to pick the matching pricing function — `anthropicTokenCost` vs
+ * `geminiTokenCost` — whose usage records are deliberately not interchangeable, because the
+ * two providers disagree about whether the prompt figure includes the cached part. Without
+ * this, every such caller writes its own model→vendor map, which is the same duplication that
+ * exporting the pricing removes.
+ *
+ * Returns `undefined` rather than falling back to a default vendor so an unrecognised model
+ * is a decision the caller has to make out loud. Silently defaulting is precisely how an
+ * unlisted model gets priced at some other tier's rates — a consumer has already had Haiku
+ * billed at Sonnet rates that way.
+ *
+ * Takes a plain `string`, not a union: the interesting callers are reading a model id back
+ * off a stored message or a config file, where it is untrusted text.
+ *
+ * @beta
+ */
+export declare function vendorOfModel(modelId: string): AIProviderType | undefined;
+
 /**
  * The {@link AIProviderType} behind a vendor label, or `undefined` for a label
  * no vendor claims.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ai",
   "description": "Genesis Foundation AI - Provider-agnostic AI configuration and shared utilities",
-  "version": "15.11.0",
+  "version": "15.12.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -52,17 +52,17 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.11.0",
-    "@genesislcap/genx": "15.11.0",
-    "@genesislcap/rollup-builder": "15.11.0",
-    "@genesislcap/ts-builder": "15.11.0",
-    "@genesislcap/uvu-playwright-builder": "15.11.0",
-    "@genesislcap/vite-builder": "15.11.0",
-    "@genesislcap/webpack-builder": "15.11.0"
+    "@genesislcap/foundation-testing": "15.12.0",
+    "@genesislcap/genx": "15.12.0",
+    "@genesislcap/rollup-builder": "15.12.0",
+    "@genesislcap/ts-builder": "15.12.0",
+    "@genesislcap/uvu-playwright-builder": "15.12.0",
+    "@genesislcap/vite-builder": "15.12.0",
+    "@genesislcap/webpack-builder": "15.12.0"
   },
   "dependencies": {
-    "@genesislcap/foundation-logger": "15.11.0",
-    "@genesislcap/foundation-utils": "15.11.0",
+    "@genesislcap/foundation-logger": "15.12.0",
+    "@genesislcap/foundation-utils": "15.12.0",
     "@microsoft/fast-foundation": "2.50.0"
   },
   "repository": {
@@ -73,5 +73,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "261d900881ea1ca2b613033af497ffd449868eb0"
+  "gitHead": "06f5ab51086c6616c6b96a7a1aebccddb3af7881"
 }