@genesislcap/ai-assistant 15.33.1 → 15.34.1

package/dist/ai-assistant.d.ts

@@ -3,6 +3,9 @@ import type { AggregateUsage } from '@genesislcap/foundation-ai';
 import { AIProviderRegistry } from '@genesislcap/foundation-ai';
 import type { AIProviderRegistryStatusEntry } from '@genesislcap/foundation-ai';
 import { AIProviderType } from '@genesislcap/foundation-ai';
+import { AITierId } from '@genesislcap/foundation-ai';
+import { AITiers } from '@genesislcap/foundation-ai';
+import { AITierVendor } from '@genesislcap/foundation-ai';
 import { BudgetExhaustedError } from '@genesislcap/foundation-ai';
 import type { CachePolicy } from '@genesislcap/foundation-ai';
 import type { ChatAttachment } from '@genesislcap/foundation-ai';
@@ -15,6 +18,7 @@ import type { ChatThinkingPolicy } from '@genesislcap/foundation-ai';
 import type { ChatToolChoice } from '@genesislcap/foundation-ai';
 import type { ChatToolDefinition } from '@genesislcap/foundation-ai';
 import type { ChatToolHandlers } from '@genesislcap/foundation-ai';
+import { Container } from '@genesislcap/web-core';
 import { ElementStyles } from '@genesislcap/web-core';
 import { GenesisElement } from '@genesislcap/web-core';
 import type { InteractionRequestOptions } from '@genesislcap/foundation-ai';
@@ -3358,6 +3362,26 @@ export declare class FoundationAiAssistant extends GenesisElement {
      * }
      * ```
      *
+     * A host that meters its spend by source can pass an optional `segments` breakdown, and
+     * the vendor's bar is drawn stacked with a legend naming each one (NEW-15):
+     *
+     * ```ts
+     * assistantEl.setVendorBudget('anthropic', {
+     *   budgetUsd: 50,
+     *   spentUsd: 12.5,
+     *   segments: [
+     *     { id: 'app', label: 'App', spentUsd: 9 },
+     *     { id: 'batch', label: 'Batch jobs', spentUsd: 3.5 },
+     *   ],
+     * });
+     * ```
+     *
+     * The labels are yours — the assistant has no vocabulary for what a host spends money on.
+     * Segments may add up to less than `spentUsd` (the remainder draws unlabelled) but never
+     * to more; a breakdown that does, or that is otherwise malformed, is dropped with a debug
+     * log and the single bar renders. Omit `segments` entirely and nothing about the meter
+     * changes.
+     *
      * Re-run it on mount and after each turn. Scope and lifetime follow the rest
      * of the session slice (per `stateKey`, survives pop-in/out and "Clear" /
      * "New chat") — except that the figures are NOT persisted to the session
@@ -3366,10 +3390,7 @@ export declare class FoundationAiAssistant extends GenesisElement {
      *
      * @beta
      */
-    setVendorBudget(vendor: string, figures: {
-        budgetUsd: number;
-        spentUsd: number;
-    } | null): boolean;
+    setVendorBudget(vendor: string, figures: VendorBudgetFigures | null): boolean;
     /**
      * When budget figures last arrived — from the host's
      * {@link FoundationAiAssistant.setVendorBudget} or the wall latch's own feed —
@@ -5232,6 +5253,22 @@ declare type ProviderRefusedDetail = NonNullable<Extract<ChatDriverResult, {
     reason: 'done';
 }>['providerRefused']>;
 
+/**
+ * Build a {@link TieredAIProviderSwitcher} — which registers the tier-shaped provider
+ * registry — and put it on the {@link (AIProviderSwitcher:variable)} token. Call once at app
+ * bootstrap.
+ *
+ * @remarks
+ * Everything here is synchronous and has to stay that way. `foundation-ai-assistant` resolves
+ * the switcher and registry tokens as it connects, and an element that connects first caches
+ * the no-op fallback — so an `await` above this call costs the whole page load its providers.
+ * Load a stored vendor preference AFTER it, through
+ * {@link TieredAIProviderSwitcher.adoptPersistedVendor}.
+ *
+ * @beta
+ */
+export declare function registerTieredAIProviders(container: Container, options: Omit<TieredAIProviderSwitcherOptions, 'container'>): TieredAIProviderSwitcher;
+
 /**
  * Name reserved for the cross-agent handoff tool — injected by OrchestratingDriver.
  *
@@ -5557,6 +5594,32 @@ export declare interface SettingsBudgetRow {
      * `Math.min(100, …)`).
      */
     barValue: number;
+    /**
+     * The stacked bar's pieces when the host broke this vendor's spend down, and `undefined`
+     * when it did not — in which case the row renders the design system's single progress bar,
+     * exactly as before (NEW-15).
+     */
+    segments?: SettingsBudgetSegment[];
+}
+
+/**
+ * One piece of a stacked budget bar, pre-computed — see {@link SettingsBudgetRow.segments}.
+ *
+ * @beta
+ */
+export declare interface SettingsBudgetSegment {
+    /** The host's segment id, or the platform's own id for the unattributed remainder. */
+    id: string;
+    /** The host's label. Empty for the remainder, which the legend does not list. */
+    label: string;
+    /** This piece's spend, e.g. `$12.34`. Empty for the remainder. */
+    figures: string;
+    /** Width as a percentage of the row's full track, already scaled to the clamped bar. */
+    widthPercent: number;
+    /** Alpha applied to the design system's accent, so the pieces read as one measure. */
+    tone: number;
+    /** Whether this piece appears in the legend — false for the unattributed remainder. */
+    legend: boolean;
 }
 
 /**
@@ -5993,6 +6056,112 @@ export declare type TemperatureInput = number | ((ctx: SystemPromptContext) => n
  */
 export declare type ThinkingPolicyInput = ChatThinkingPolicy | ((ctx: SystemPromptContext) => ChatThinkingPolicy | undefined | Promise<ChatThinkingPolicy | undefined>);
 
+/**
+ * Which cloud vendor backs the tier-shaped provider registry, plus the means to move it at
+ * runtime (GENC-1610).
+ *
+ * @remarks
+ * Upstreamed from Genesis Create, which has run this shape in production: a registry keyed by
+ * tier (`low` / `high` / `reasoning`), a vendor switch that rebuilds it in place, and the other
+ * vendor kept alive as a standby entry. Agents keep resolving tier names, so a switch never
+ * touches agent config.
+ *
+ * Register it on the {@link (AIProviderSwitcher:interface)} DI token — via
+ * {@link registerTieredAIProviders} — and the settings modal's vendor UI (or an app's own
+ * control) drives it.
+ *
+ * @beta
+ */
+export declare class TieredAIProviderSwitcher implements AIProviderSwitcher {
+    readonly vendors: readonly AITierVendor[];
+    private readonly options;
+    private readonly defaultTier;
+    private readonly registry;
+    private readonly listeners;
+    private _vendor;
+    constructor(options: TieredAIProviderSwitcherOptions);
+    get vendor(): AITierVendor;
+    /**
+     * A user-driven switch: move the registry, then tell the app so it can persist the choice.
+     * An unknown vendor is ignored.
+     */
+    switchTo(vendor: string): void;
+    /**
+     * Adopt a vendor the app read back from its own store — the same registry move as
+     * {@link TieredAIProviderSwitcher.switchTo}, without the `onSwitch` callback, because this
+     * value came FROM the store and writing it back would be a pointless round-trip on load.
+     *
+     * Exists because registration has to stay synchronous: an element that connects before the
+     * token is registered caches the platform's no-op fallback, so an app cannot await its
+     * stored preference before constructing this. It boots on `initialVendor` and adopts the
+     * stored one a moment later, through a registry that is mutable and held by reference.
+     */
+    adoptPersistedVendor(vendor: string): void;
+    subscribe(listener: (vendor: string) => void): () => void;
+    /** The registry move both entry points share, and nothing else. */
+    private apply;
+    private build;
+    private isKnownVendor;
+}
+
+/**
+ * Options for {@link TieredAIProviderSwitcher}.
+ *
+ * @beta
+ */
+export declare interface TieredAIProviderSwitcherOptions {
+    /** DI container the provider registry is registered on. */
+    container: Container;
+    /**
+     * Where each vendor's tiers post, as a function of the vendor — for example one that
+     * returns `/gwf/ai-service/<vendor>/chat`.
+     *
+     * A function and never a plain string, because the switcher builds MORE than one vendor:
+     * the active one, a standby for each other vendor, and every tier again after a switch. A
+     * single string would send all of them to the one vendor's proxy, so picking the other vendor
+     * in settings would post Anthropic-shaped requests to a Gemini route — failing on every turn
+     * rather than at bootstrap. An app that only ever reaches one vendor narrows `vendors` and
+     * still passes a function; it just ignores its argument.
+     */
+    serverEndpoint: (vendor: AITierVendor) => string;
+    /**
+     * The vendor to boot on. Required, and deliberately so: the platform has no opinion about
+     * which cloud vendor an app should use, and a silent default would make one app's choice
+     * look like a platform decision.
+     */
+    initialVendor: AITierVendor;
+    /**
+     * The vendors this app can switch between. Defaults to every vendor in the table.
+     *
+     * Narrow it when the app's proxy can only reach one: the others would otherwise report a
+     * status, and the assistant's partial-wall UX reads statuses — so a walled vendor would
+     * offer "switch to the other one" about a vendor that has no key behind it.
+     */
+    vendors?: readonly AITierVendor[];
+    /**
+     * Which tier the registry resolves for a caller that names no provider. Defaults to
+     * `'high'`.
+     *
+     * High rather than the cheapest, because of what resolves through it: an orchestrated turn
+     * classifies against the REGISTRY DEFAULT, so the classifier sees the session's accumulated
+     * history on whatever model this names. On the smallest-window tier, a session grown to size
+     * on a bigger model can hand the classifier a history that no longer fits — and the routing
+     * turn fails at the moment it was supposed to hand off to a model that could have taken it.
+     */
+    defaultTier?: AITierId;
+    /** The tier table to build from. Defaults to the platform's. */
+    tiers?: AITiers;
+    /**
+     * Called when {@link TieredAIProviderSwitcher.switchTo} accepts a vendor — the hook for an
+     * app that persists the user's choice.
+     *
+     * Fires even when the chosen vendor is the one already active. That is not a redundant
+     * call: during boot the registry shows this app's initial vendor while a stored preference
+     * may still be loading, so "confirm what I can see" and "leave it alone" are different acts.
+     */
+    onSwitch?: (vendor: AITierVendor) => void;
+}
+
 /**
  * A chat message lifted into the debug-log timeline as a `kind: 'message'` entry.
  *
@@ -6305,11 +6474,46 @@ export declare const userIconSvg = "<svg viewBox=\"0 0 24 24\" fill=\"none\" xml
  *
  * @beta
  */
-declare interface VendorBudgetFigures {
+export declare interface VendorBudgetFigures {
     /** The vendor's budget cap in USD. Finite and `>= 0`. */
     budgetUsd: number;
     /** Metered spend against that cap in USD. Finite and `>= 0`; may exceed the cap. */
     spentUsd: number;
+    /**
+     * Optional breakdown of {@link VendorBudgetFigures.spentUsd} by whatever the host meters
+     * spend by — a surface, a team, an environment. Given, the vendor's bar is drawn stacked
+     * with a legend; omitted, it is the single bar it has always been.
+     *
+     * Host-named, with no platform vocabulary: the assistant has no idea what a host's spend
+     * sources are, and inventing labels for them is how a product word ends up in the platform.
+     * Segments may cover less than the total (the remainder simply draws unlabelled); they may
+     * not cover more, which would be a breakdown of a figure other than the one on screen.
+     *
+     * ORDER IS SIGNIFICANT: the bar and legend are drawn in array order, and the first segment
+     * gets the strongest tone (full strength whenever the whole spend is attributed). Feed the
+     * sources in a fixed, meaningful order — the one you want drawn first, first — and keep it
+     * across re-feeds; a host that re-sorts its sources per response moves the strongest tone
+     * between them with no change in the money.
+     */
+    segments?: VendorBudgetSegment[];
+}
+
+/**
+ * One slice of a vendor's spend — see {@link VendorBudgetFigures.segments}.
+ *
+ * @beta
+ */
+export declare interface VendorBudgetSegment {
+    /**
+     * Identifies the source. Must be unique within a breakdown, and must not be
+     * `__remainder__`, which the meter reserves for unattributed spend; a breakdown that breaks
+     * either rule is dropped. It does not decide drawing order or tone — array order does.
+     */
+    id: string;
+    /** What the host calls this slice of the spend; rendered verbatim in the legend. */
+    label: string;
+    /** This slice's share of the spend in USD. Finite and `>= 0`. */
+    spentUsd: number;
 }
 
 /**

package/dist/chat-driver.cjs

@@ -19,6 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/chat-driver-node.ts
 var chat_driver_node_exports = {};
 __export(chat_driver_node_exports, {
+  AI_TIER_IDS: () => AI_TIER_IDS,
+  AI_TIER_VENDORS: () => AI_TIER_VENDORS,
   ANTHROPIC_CACHE_READ_MULTIPLIER: () => ANTHROPIC_CACHE_READ_MULTIPLIER,
   ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER: () => ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER,
   ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER: () => ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER,
@@ -26,6 +28,7 @@ __export(chat_driver_node_exports, {
   AnthropicProvider: () => AnthropicProvider,
   AnthropicTransport: () => AnthropicTransport,
   ChatDriver: () => ChatDriver,
+  DEFAULT_AI_TIERS: () => DEFAULT_AI_TIERS,
   DEFAULT_PROVIDER_REFUSED_MESSAGE: () => DEFAULT_PROVIDER_REFUSED_MESSAGE,
   EMPTY_RESPONSE_NUDGE: () => EMPTY_RESPONSE_NUDGE,
   GEMINI_CACHED_INPUT_MULTIPLIER: () => GEMINI_CACHED_INPUT_MULTIPLIER,
@@ -59,6 +62,7 @@ __export(chat_driver_node_exports, {
   getMetaEvents: () => getMetaEvents,
   isObservableAIProviderRegistry: () => isObservableAIProviderRegistry,
   messageUsage: () => messageUsage,
+  resolveAITiers: () => resolveAITiers,
   restoreMachine: () => restoreMachine,
   strictFallbackAgent: () => strictFallbackAgent,
   sumUsage: () => sumUsage,
@@ -1292,6 +1296,7 @@ function anthropicTokenCost(model, usage) {
 }
 var GEMINI_LONG_CONTEXT_THRESHOLD = 2e5;
 var GEMINI_CACHED_INPUT_MULTIPLIER = 0.1;
+var GEMINI_3_8_FLASH_INTRO_RATE_ENDS = Date.parse("2027-01-01T00:00:00Z");
 var GEMINI_PRICING = {
   "gemini-2.5-flash-lite": {
     kind: "flat",
@@ -3541,6 +3546,87 @@ var MutableAIProviderRegistry = class _MutableAIProviderRegistry {
   }
 };
 
+// ../../foundation-ai/dist/esm/tiers/ai-tiers.js
+var AI_TIER_IDS = ["low", "high", "reasoning"];
+var AI_TIER_VENDORS = ["anthropic", "gemini"];
+var AI_STALL_TIMEOUT_MS = 6e4;
+var AI_NO_RESPONSE_TIMEOUT_MS = 3e5;
+var DEFAULT_AI_TIERS = Object.freeze({
+  anthropic: Object.freeze({
+    low: Object.freeze({
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 16e3,
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    }),
+    // The heavy tier: whole-file writes, and adaptive thinking out of the same budget
+    // wherever a caller leaves thinking on — hence Sonnet 5's full 128K ceiling rather
+    // than a figure that only fits one of the two.
+    high: Object.freeze({
+      model: "claude-sonnet-5",
+      maxTokens: 128e3,
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    }),
+    // One-shot judgement calls rather than tool loops, so a smaller ceiling is ample:
+    // `max_tokens` is only a cap, and this tier never emits a whole file.
+    //
+    // Opus 4.8 rather than the 4.7 Create benched: the same price ($5 / $25) and the same 1M
+    // window, but 4.8 supports native structured output where 4.7 takes the forced-tool
+    // fallback — and structured judgement is what this tier is asked for most (review of #2540).
+    reasoning: Object.freeze({
+      model: "claude-opus-4-8",
+      maxTokens: 32e3,
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    })
+  }),
+  gemini: Object.freeze({
+    low: Object.freeze({
+      model: "gemini-3.1-flash-lite",
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    }),
+    // On an INTRODUCTORY rate that doubles to $1.50 / $7.50 on 2027-01-01, from which point it
+    // is dearer on input than the gemini-3.5-flash it replaced. Chosen at the introductory rate
+    // knowingly; `ai-tiers.test.ts` fails that day to force the re-bench.
+    high: Object.freeze({
+      model: "gemini-3.8-flash",
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    }),
+    // A PREVIEW model: no stability guarantee, and it may be withdrawn at short notice (its
+    // transport warns on every construction). Accepted knowingly as the platform default because
+    // no stable Gemini Pro was on offer when the tiers were benched; revisit as soon as Google
+    // promotes, deprecates or withdraws it, since every app on this default inherits the risk.
+    reasoning: Object.freeze({
+      model: "gemini-3.1-pro-preview",
+      stallTimeoutMs: AI_STALL_TIMEOUT_MS,
+      timeoutMs: AI_NO_RESPONSE_TIMEOUT_MS
+    })
+  })
+});
+function resolveAITiers(overrides) {
+  if (!(overrides === null || overrides === void 0 ? void 0 : overrides.anthropic) && !(overrides === null || overrides === void 0 ? void 0 : overrides.gemini))
+    return DEFAULT_AI_TIERS;
+  return Object.freeze({
+    anthropic: mergeVendor(DEFAULT_AI_TIERS.anthropic, overrides.anthropic),
+    gemini: mergeVendor(DEFAULT_AI_TIERS.gemini, overrides.gemini)
+  });
+}
+function mergeVendor(defaults, overrides) {
+  var _a;
+  const merged = {};
+  for (const tier of AI_TIER_IDS) {
+    const defined = Object.fromEntries(Object.entries((_a = overrides === null || overrides === void 0 ? void 0 : overrides[tier]) !== null && _a !== void 0 ? _a : {}).filter(([, value]) => value !== void 0));
+    const entry = Object.assign(Object.assign({}, defaults[tier]), defined);
+    Object.freeze(entry);
+    merged[tier] = entry;
+  }
+  Object.freeze(merged);
+  return merged;
+}
+
 // src/channel/ai-activity-bus.ts
 var NOOP_ACTIVITY_BUS = { publish: () => {
 } };
@@ -8406,6 +8492,8 @@ function withFreshMetaSnapshot(stored, fresh) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AI_TIER_IDS,
+  AI_TIER_VENDORS,
   ANTHROPIC_CACHE_READ_MULTIPLIER,
   ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER,
   ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER,
@@ -8413,6 +8501,7 @@ function withFreshMetaSnapshot(stored, fresh) {
   AnthropicProvider,
   AnthropicTransport,
   ChatDriver,
+  DEFAULT_AI_TIERS,
   DEFAULT_PROVIDER_REFUSED_MESSAGE,
   EMPTY_RESPONSE_NUDGE,
   GEMINI_CACHED_INPUT_MULTIPLIER,
@@ -8446,6 +8535,7 @@ function withFreshMetaSnapshot(stored, fresh) {
   getMetaEvents,
   isObservableAIProviderRegistry,
   messageUsage,
+  resolveAITiers,
   restoreMachine,
   strictFallbackAgent,
   sumUsage,