@anvaka/vue-llm 0.2.0 → 0.3.1

package/README.md

@@ -3,9 +3,11 @@
 Browser-only LLM client + Vue 3 plugin, provider adapters, and lightweight components.
 
 ## Features
-- Provider factory with 8 built-in providers (OpenAI, Anthropic, Grok, Gemini, Ollama, Llama Server, OpenRouter, Custom) – extend with `registerProvider()`
+- Provider factory with 10 built-in providers (OpenAI, Anthropic, Bedrock, Grok, Gemini, Ollama, Llama Server, OpenRouter, DeepSeek, Custom) – extend with `registerProvider()`
 - LocalStorage-based config store (custom storage adapter supported)
 - Streaming + promise requests via `llmClient.stream()`
+- Normalized usage + USD cost on every response (override built-in rates per app or per model)
+- Automatic prompt caching for Claude (Anthropic + Bedrock) — caches the system+tools prefix, plus the rolling conversation in agent loops; opt out with `promptCache: false`
 - Vue plugin for dependency injection
 - `useLLM()` composable with reactive streaming state
 - Ready-to-use components: `ProviderSelector`, `LLMConfigModal`, `StoredKeysManager`
@@ -121,13 +123,89 @@ For scripts outside Vue components, use the singleton exports:
 import { llmClient, configStore, keyStore } from '@anvaka/vue-llm'
 
 // Stream directly
-await llmClient.stream({ messages: [...] }, chunk => console.log(chunk.fullContent))
+const { content, usage, cost } = await llmClient.stream(
+  { messages: [...] },
+  chunk => console.log(chunk.fullContent)
+)
 
 // Manage configs
 configStore.saveConfig('my-provider', { ... })
 configStore.setActiveProviderId('my-provider')
 ```
 
+## Usage & Cost
+
+Every response carries a normalized `usage` object and a USD `cost` breakdown when the model's rates are known. Stream chunks expose a running `fullUsage` so consumers can render a live cost counter.
+
+```js
+const { content, usage, cost } = await client.stream({ messages: [...] })
+
+usage // { inputTokens, outputTokens, totalTokens,
+      //   cachedInputTokens?, cacheCreationInputTokens?, reasoningTokens?, raw }
+cost  // { total, input, cachedInput, cacheCreation, output, currency, rates }
+      // or null when the model isn't in the rates table
+```
+
+`runAgentLoop` aggregates usage across all iterations (each tool round-trip is one call) and emits a `usage` event per iteration:
+
+```js
+const { messages, usage, cost } = await client.runAgentLoop({
+  messages: [{ role: 'user', content: '7 * 11?' }],
+  tools, executors,
+  onEvent: ev => {
+    if (ev.type === 'usage') console.log(`iter cost: ${ev.cost?.total}`)
+  }
+})
+```
+
+### Prompt caching (Claude)
+
+Anthropic and Bedrock requests are sent with `cache_control` markers by default, so repeated prefixes are read from cache instead of re-billed at full input price. Two prefixes are tagged:
+
+- **System + tools** — on every Claude request. The static prefix recurs identically across calls and runs within the cache TTL (~5 min).
+- **Rolling conversation** — added by `runAgentLoop` only, since it re-sends the whole growing transcript each turn. Iteration *N* reads iterations `1..N-1` from cache and only writes the new turn.
+
+Cache hits and writes surface in the usual `usage` fields (`cachedInputTokens`, `cacheCreationInputTokens`) and are priced via the `cachedInput` / `cacheCreation` rate keys. No setup is required — prefixes under the model's minimum cacheable length simply aren't cached (no error).
+
+Disable it per call or per provider config:
+
+```js
+client.stream({ messages: [...], promptCache: false })   // single request
+configStore.saveConfig('claude', { ...cfg, promptCache: false }) // all requests for this provider
+```
+
+### Overriding rates
+
+Built-in rates are sourced from public pricing pages and *will* drift. Three ways to override, in priority order:
+
+```js
+// 1. Per-instance — wins over everything
+import { LLMClient } from '@anvaka/vue-llm'
+const client = new LLMClient({
+  pricing: {
+    openai: { 'gpt-4o': { input: 1.50, output: 6.00, cachedInput: 0.75 } }
+  }
+})
+
+// 2. Global runtime override
+import { registerPricing } from '@anvaka/vue-llm'
+registerPricing('openai', 'gpt-4o', { input: 1.50, output: 6.00 })
+
+// 3. Inline (without LLMClient)
+import { calculateCost } from '@anvaka/vue-llm/pricing'
+const cost = calculateCost(usage, { provider: 'openai', model: 'gpt-4o' })
+```
+
+Rate keys: `input` (uncached prompt, per 1M tokens, USD), `output`, optional `cachedInput` (prompt-cache hits — defaults to `input` if omitted), optional `cacheCreation` (Anthropic-only cache-write premium).
+
+Model lookup is exact match first, then longest-prefix match — so registering `claude-haiku-4-5` automatically covers `claude-haiku-4-5-20251001`.
+
+```js
+// Pricing-only import (no Vue):
+import { calculateCost, formatCost, registerPricing, DEFAULT_RATES } from '@anvaka/vue-llm/pricing'
+formatCost(0.00012) // "$0.000120"
+```
+
 ## Theming
 Override any `--llm-*` CSS variable globally or per container.
 ```css
@@ -150,7 +228,7 @@ registerProvider('my-provider', MyProvider)
 // From '@anvaka/vue-llm/providers'
 import { 
   BaseProvider,
-  PROVIDERS,           // { OPENAI, ANTHROPIC, GROK, GEMINI, OLLAMA, LLAMA_SERVER, OPENROUTER, CUSTOM }
+  PROVIDERS,           // { OPENAI, ANTHROPIC, BEDROCK, GROK, GEMINI, OLLAMA, LLAMA_SERVER, OPENROUTER, DEEPSEEK, CUSTOM }
   DEFAULT_CONFIGS,     // Default configs for each provider type
   createProvider,      // (type, config) => Provider
   registerProvider,    // (type, ProviderClass) => void

package/dist/core/LLMClient.js

@@ -1,12 +1,25 @@
-import { createProviderFlexible as I } from "../providers/factory.js";
-class $ {
-  constructor({ configStore: t, logger: s } = {}) {
-    this.configStore = t, this.logger = s || console, this.config = null, this.provider = null, this.usageTracker = null;
+import { createProviderFlexible as U } from "../providers/factory.js";
+import { calculateCost as A } from "../pricing/calculate.js";
+class P {
+  constructor({ configStore: t, logger: s, pricing: i } = {}) {
+    this.configStore = t, this.logger = s || console, this.config = null, this.provider = null, this.usageTracker = null, this.pricing = i || null;
+  }
+  // Compute USD cost for a usage object using this client's active provider /
+  // model + any per-instance overrides. Returns null when rates are unknown.
+  // Exposed so consumers can re-cost historical usage objects without
+  // reaching into the pricing module directly.
+  costFor(t, { provider: s, model: i } = {}) {
+    var r, e;
+    return A(t, {
+      provider: s || ((r = this.config) == null ? void 0 : r.provider),
+      model: i || ((e = this.config) == null ? void 0 : e.model),
+      pricing: this.pricing
+    });
   }
   async initialize(t = null) {
     if (this.config = t || this.configStore.getActiveConfig(), !this.config)
       throw new Error("LLM not configured");
-    this.provider = I(this.config.provider, this.config), await this.provider.initialize(), this.usageTracker = this._createUsageTracker();
+    this.provider = U(this.config.provider, this.config), await this.provider.initialize(), this.usageTracker = this._createUsageTracker();
   }
   async ensureInitialized() {
     this.provider || await this.initialize();
@@ -35,17 +48,18 @@ class $ {
     }
   }
   _createUsageTracker() {
-    return {
+    const t = {
       totalTokens: 0,
       totalCost: 0,
-      recordUsage: (t, s) => {
-        var i;
-        (i = s.usage) != null && i.tokens && (this.totalTokens += s.usage.tokens);
+      recordUsage: (s, i) => {
+        var r;
+        ((r = i == null ? void 0 : i.usage) == null ? void 0 : r.totalTokens) != null && (t.totalTokens += i.usage.totalTokens);
       },
-      recordPartialUsage: (t) => {
-        t != null && t.tokens && (this.totalTokens += t.tokens);
+      recordPartialUsage: (s) => {
+        (s == null ? void 0 : s.totalTokens) != null && (t.totalTokens += s.totalTokens);
       }
     };
+    return t;
   }
   validateCapabilities(t) {
     var i;
@@ -75,10 +89,12 @@ class $ {
   async stream(t, s) {
     await this.ensureInitialized();
     const i = this.validateCapabilities({ ...t, stream: !0, model: t.model || this.config.model, requestId: this.generateRequestId() }), r = t.messages;
-    let e = "";
-    return await this.provider.streamRequest(r, i, (n) => {
-      e = n.fullContent, s && s(n);
-    }), e;
+    let e = "", n = null;
+    return await this.provider.streamRequest(r, i, (o) => {
+      e = o.fullContent, o.fullUsage && (n = o.fullUsage);
+      const l = o.fullUsage ? { ...o, cost: this.costFor(o.fullUsage, { provider: this.config.provider, model: i.model }) } : o;
+      s && s(l);
+    }), { content: e, usage: n, cost: this.costFor(n, { provider: this.config.provider, model: i.model }) };
   }
   // Multi-turn tool-calling loop. Each iteration:
   //  1) stream a model response (text + accumulated tool_calls)
@@ -104,47 +120,61 @@ class $ {
     temperature: n,
     model: o,
     maxTokens: l,
-    enableThinking: u
+    enableThinking: d
   } = {}) {
     if (await this.ensureInitialized(), !this.provider.hasCapability("tools"))
       throw new Error("Configured provider does not support tools");
-    const h = t.slice();
-    let c = 0, m = null;
-    for (; c < e; ) {
-      c++, r && r({ type: "iter-start", iter: c });
-      const b = this.validateCapabilities({
-        messages: h,
+    const c = t.slice();
+    let p = 0, m = null;
+    const f = { inputTokens: 0, outputTokens: 0, totalTokens: 0, cachedInputTokens: 0, cacheCreationInputTokens: 0, reasoningTokens: 0 };
+    let b = !1;
+    for (; p < e; ) {
+      p++, r && r({ type: "iter-start", iter: p });
+      const x = this.validateCapabilities({
+        messages: c,
         tools: s,
         stream: !0,
         model: o || this.config.model,
         temperature: n ?? this.config.temperature,
         maxTokens: l ?? this.config.maxTokens ?? 4096,
-        enableThinking: u ?? !1,
+        enableThinking: d ?? !1,
+        // Re-sends the whole growing conversation each turn, so cache the
+        // rolling transcript prefix (Anthropic-family providers honor this).
+        cacheTranscript: !0,
         requestId: this.generateRequestId()
-      }), p = await this.provider.streamRequest(h, b, (a) => {
+      }), h = await this.provider.streamRequest(c, x, (a) => {
         a.content && r && r({ type: "text-delta", text: a.content }), a.toolCallDelta && r && r({ type: "tool-call-delta", delta: a.toolCallDelta });
-      }), v = (p == null ? void 0 : p.content) || "", d = (p == null ? void 0 : p.toolCalls) || [], w = { role: "assistant", content: v };
-      if (d.length && (w.tool_calls = d), h.push(w), r && r({ type: "assistant-message", content: v, toolCalls: d }), !d.length) {
+      }), q = (h == null ? void 0 : h.content) || "", y = (h == null ? void 0 : h.toolCalls) || [], C = (h == null ? void 0 : h.thinking) || "", w = (h == null ? void 0 : h.usage) || null;
+      if (w) {
+        b = !0;
+        for (const a of Object.keys(f))
+          w[a] != null && (f[a] += w[a]);
+        r && r({ type: "usage", usage: w, cost: this.costFor(w, { provider: this.config.provider, model: x.model }) });
+      }
+      const k = { role: "assistant", content: q };
+      if (y.length && (k.tool_calls = y), C && (k.thinking = C), c.push(k), r && r({ type: "assistant-message", content: q, toolCalls: y, thinking: C }), !y.length) {
         m = "no-tool-calls";
         break;
       }
-      for (const a of d) {
+      for (const a of y) {
         r && r({ type: "tool-call", id: a.id, name: a.name, args: a.args });
-        const _ = i && i[a.name];
-        let y;
-        if (!_)
-          y = `Error: unknown tool '${a.name}'`;
+        const R = i && i[a.name];
+        let T;
+        if (!R)
+          T = `Error: unknown tool '${a.name}'`;
         else
           try {
-            const f = await _(a.args || {});
-            y = typeof f == "string" ? f : JSON.stringify(f ?? "");
-          } catch (f) {
-            y = `Error: ${(f == null ? void 0 : f.message) || String(f)}`;
+            const u = await R(a.args || {});
+            T = typeof u == "string" ? u : JSON.stringify(u ?? "");
+          } catch (u) {
+            T = `Error: ${(u == null ? void 0 : u.message) || String(u)}`;
           }
-        h.push({ role: "tool", tool_call_id: a.id, content: y }), r && r({ type: "tool-result", id: a.id, name: a.name, content: y });
+        c.push({ role: "tool", tool_call_id: a.id, content: T }), r && r({ type: "tool-result", id: a.id, name: a.name, content: T });
       }
     }
-    return m || (m = "max-iters"), r && r({ type: "stop", reason: m, iterations: c }), { messages: h, iterations: c, stopReason: m };
+    m || (m = "max-iters");
+    const g = b ? f : null, v = this.costFor(g, { provider: this.config.provider, model: o || this.config.model });
+    return r && r({ type: "stop", reason: m, iterations: p, usage: g, cost: v }), { messages: c, iterations: p, stopReason: m, usage: g, cost: v };
   }
   generateRequestId() {
     return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
@@ -185,12 +215,12 @@ class $ {
   createLLMWrapper(t, s = null, i = null) {
     const r = this;
     function e(n, o = {}) {
-      return new S(r, t, n, o, s, i);
+      return new $(r, t, n, o, s, i);
     }
     return e;
   }
 }
-class S {
+class $ {
   constructor(t, s, i, r, e, n) {
     this.client = t, this.contextNode = s, this.prompt = i, this.options = r || {}, this.originatingCode = e, this.defaultPresetName = n, this.targetNode = null, this.targetAttributes = {}, this.operationName = null, this._executed = !1, this._promise = null;
   }
@@ -229,8 +259,8 @@ class S {
     };
     try {
       if (this.targetNode) {
-        const u = r({ ...n, stream: !0 });
-        return await this._streamIntoTarget(e, u, s, i);
+        const d = r({ ...n, stream: !0 });
+        return await this._streamIntoTarget(e, d, s, i);
       }
       const l = r({ ...n, stream: !1 });
       return await this._promiseResponse(e, l, s, i);
@@ -248,10 +278,10 @@ class S {
       throw new Error("Provider presets require a configured ConfigStore instance");
     const s = (e = (r = this.client).getConfigByName) == null ? void 0 : e.call(r, t);
     if (!s) {
-      const l = (((o = (n = this.client.configStore).getEnabledConfigs) == null ? void 0 : o.call(n)) || []).map((h) => h.name || `${h.provider} (${h.baseUrl})`).filter(Boolean), u = l.length ? ` Available presets: ${l.join(", ")}` : " No configured providers found.";
-      throw new Error(`Provider preset '${t}' not found.${u}`);
+      const l = (((o = (n = this.client.configStore).getEnabledConfigs) == null ? void 0 : o.call(n)) || []).map((c) => c.name || `${c.provider} (${c.baseUrl})`).filter(Boolean), d = l.length ? ` Available presets: ${l.join(", ")}` : " No configured providers found.";
+      throw new Error(`Provider preset '${t}' not found.${d}`);
     }
-    const i = I(s.provider, s);
+    const i = U(s.provider, s);
     return await i.initialize(), { provider: i, config: s, cleanup: () => {
       var l;
       return (l = i.cancelAllRequests) == null ? void 0 : l.call(i);
@@ -271,44 +301,46 @@ class S {
       }
   }
   async _streamIntoTarget(t, s, i, r) {
-    var c, m, b, p, v, d, w, a, _, y, f, C, T, k;
+    var p, m, f, b, g, v, x, h, q, y, C, w, k, a, R, T;
     let e, n;
-    typeof this.targetNode == "string" ? (n = this.targetNode, e = this.contextNode.createChild(n), (c = e.setSelected) == null || c.call(e)) : (e = this.targetNode, n = ((m = e.getText) == null ? void 0 : m.call(e)) || ""), this._applyAttributes(e);
+    typeof this.targetNode == "string" ? (n = this.targetNode, e = this.contextNode.createChild(n), (p = e.setSelected) == null || p.call(e)) : (e = this.targetNode, n = ((m = e.getText) == null ? void 0 : m.call(e)) || ""), this._applyAttributes(e);
     const o = r == null ? void 0 : r.name;
-    o && e.addTag && e.addTag("provider", o), (b = e.addLLMLog) == null || b.call(e, this.operationName || "streaming-request", {
+    o && e.addTag && e.addTag("provider", o), (f = e.addLLMLog) == null || f.call(e, this.operationName || "streaming-request", {
       provider: r == null ? void 0 : r.provider,
       model: r == null ? void 0 : r.model,
       messages: t,
       options: s
-    }), (p = e.setStreamingState) == null || p.call(e, !0), e._activeRequestId = s.requestId;
-    let l = "", u = null, h = 0;
+    }), (b = e.setStreamingState) == null || b.call(e, !0), e._activeRequestId = s.requestId;
+    let l = "", d = null, c = null;
     try {
-      return await i.streamRequest(t, s, (g) => {
-        var x, q, R;
-        g.content && (l = g.fullContent, (x = e.setText) == null || x.call(e, l)), (q = g.usage) != null && q.tokens && (h += g.usage.tokens), g.finishReason && (u = g.finishReason), g.done && ((R = e.setStreamingState) == null || R.call(e, !1), e._activeRequestId = null);
-      }), (v = e.addLLMLog) == null || v.call(e, (this.operationName || "streaming-request") + "-response", { requestId: s.requestId }, { content: l, usage: { tokens: h } }), u === "length" ? ((d = e.setAttribute) == null || d.call(e, "_truncated", !0), (w = e.addLog) == null || w.call(e, "Response truncated. Increase Max Tokens.", "warn", { finish_reason: "length" })) : (a = e.setAttribute) == null || a.call(e, "_truncated", !1), await ((_ = e.persistNow) == null ? void 0 : _.call(e)), e;
-    } catch (g) {
-      throw (y = e.addLLMLog) == null || y.call(e, (this.operationName || "streaming-request") + "-error", { requestId: s.requestId }, null, g), (f = e.setStreamingState) == null || f.call(e, !1), e._activeRequestId = null, (C = e.setText) == null || C.call(e, `Error: ${g.message}`), (T = e.setAttribute) == null || T.call(e, "_truncated", !1), await ((k = e.persistNow) == null ? void 0 : k.call(e)), g;
+      await i.streamRequest(t, s, (_) => {
+        var I, S;
+        _.content && (l = _.fullContent, (I = e.setText) == null || I.call(e, l)), _.fullUsage && (c = _.fullUsage), _.finishReason && (d = _.finishReason), _.done && ((S = e.setStreamingState) == null || S.call(e, !1), e._activeRequestId = null);
+      });
+      const u = (v = (g = this.client).costFor) == null ? void 0 : v.call(g, c, { provider: r == null ? void 0 : r.provider, model: s.model });
+      return (x = e.addLLMLog) == null || x.call(e, (this.operationName || "streaming-request") + "-response", { requestId: s.requestId }, { content: l, usage: c, cost: u }), d === "length" ? ((h = e.setAttribute) == null || h.call(e, "_truncated", !0), (q = e.addLog) == null || q.call(e, "Response truncated. Increase Max Tokens.", "warn", { finish_reason: "length" })) : (y = e.setAttribute) == null || y.call(e, "_truncated", !1), await ((C = e.persistNow) == null ? void 0 : C.call(e)), e;
+    } catch (u) {
+      throw (w = e.addLLMLog) == null || w.call(e, (this.operationName || "streaming-request") + "-error", { requestId: s.requestId }, null, u), (k = e.setStreamingState) == null || k.call(e, !1), e._activeRequestId = null, (a = e.setText) == null || a.call(e, `Error: ${u.message}`), (R = e.setAttribute) == null || R.call(e, "_truncated", !1), await ((T = e.persistNow) == null ? void 0 : T.call(e)), u;
     }
   }
   async _promiseResponse(t, s, i, r) {
-    var u, h, c, m, b, p, v;
+    var d, c, p, m, f, b, g;
     const e = i.prepareRequest(t, s), n = await i.makeRequest(e), o = i.processResponse(n);
-    if ((o.finishReason || ((h = (u = n == null ? void 0 : n.choices) == null ? void 0 : u[0]) == null ? void 0 : h.finish_reason) || null) === "length")
+    if ((o.finishReason || ((c = (d = n == null ? void 0 : n.choices) == null ? void 0 : d[0]) == null ? void 0 : c.finish_reason) || null) === "length")
       try {
         this.contextNode.setAttribute("_truncated", !0);
-      } catch (d) {
-        (m = (c = this.client.logger) == null ? void 0 : c.warn) == null || m.call(c, "Unable to mark node as truncated", { error: d });
+      } catch (v) {
+        (m = (p = this.client.logger) == null ? void 0 : p.warn) == null || m.call(p, "Unable to mark node as truncated", { error: v });
       }
     else
       try {
         this.contextNode.setAttribute("_truncated", !1);
-      } catch (d) {
-        (p = (b = this.client.logger) == null ? void 0 : b.warn) == null || p.call(b, "Unable to clear truncated marker on node", { error: d });
+      } catch (v) {
+        (b = (f = this.client.logger) == null ? void 0 : f.warn) == null || b.call(f, "Unable to clear truncated marker on node", { error: v });
       }
-    return ((v = o.content) == null ? void 0 : v.trim()) || "";
+    return ((g = o.content) == null ? void 0 : g.trim()) || "";
   }
 }
 export {
-  $ as LLMClient
+  P as LLMClient
 };

package/dist/index.js

@@ -1,38 +1,46 @@
 import { LLMClient as l } from "./core/LLMClient.js";
-import { ConfigStore as S } from "./core/configStore.js";
-import { KeyStore as p, maskApiKey as M } from "./core/keyStore.js";
-import { LocalStorageAdapter as s, MemoryStorageAdapter as x } from "./core/storageAdapter.js";
-import { DEFAULT_CONFIGS as g, PROVIDERS as _, createProvider as C, createProviderFlexible as O, registerProvider as u } from "./providers/factory.js";
+import { ConfigStore as m } from "./core/configStore.js";
+import { KeyStore as p, maskApiKey as s } from "./core/keyStore.js";
+import { LocalStorageAdapter as g, MemoryStorageAdapter as x } from "./core/storageAdapter.js";
+import { DEFAULT_CONFIGS as d, PROVIDERS as C, createProvider as _, createProviderFlexible as u, registerProvider as O } from "./providers/factory.js";
+import { DEFAULT_RATES as E } from "./pricing/rates.js";
+import { calculateCost as A, clearPricingOverrides as v, formatCost as F, lookupRates as R, registerPricing as T } from "./pricing/calculate.js";
 import { createLLM as r } from "./vue/plugin.js";
-import { LLMPlugin as P, LLM_CLIENT_SYMBOL as E, LLM_CONFIG_SYMBOL as v, LLM_KEYSTORE_SYMBOL as A } from "./vue/plugin.js";
-import { createDefaultConfig as I, useLLM as K } from "./vue/useLLM.js";
-import { default as k } from "./vue/components/ProviderSelector.vue.js";
-import { default as D } from "./vue/components/LLMConfigModal.vue.js";
-import { default as R } from "./vue/components/StoredKeysManager.vue.js";
-const e = r({}), t = e.client, L = e.configStore, a = e.keyStore;
+import { LLMPlugin as D, LLM_CLIENT_SYMBOL as I, LLM_CONFIG_SYMBOL as K, LLM_KEYSTORE_SYMBOL as Y } from "./vue/plugin.js";
+import { createDefaultConfig as N, useLLM as G } from "./vue/useLLM.js";
+import { default as b } from "./vue/components/ProviderSelector.vue.js";
+import { default as h } from "./vue/components/LLMConfigModal.vue.js";
+import { default as q } from "./vue/components/StoredKeysManager.vue.js";
+const e = r({}), t = e.client, a = e.configStore, i = e.keyStore;
 export {
-  S as ConfigStore,
-  g as DEFAULT_CONFIGS,
+  m as ConfigStore,
+  d as DEFAULT_CONFIGS,
+  E as DEFAULT_RATES,
   p as KeyStore,
   l as LLMClient,
-  D as LLMConfigModal,
-  P as LLMPlugin,
-  E as LLM_CLIENT_SYMBOL,
-  v as LLM_CONFIG_SYMBOL,
-  A as LLM_KEYSTORE_SYMBOL,
-  s as LocalStorageAdapter,
+  h as LLMConfigModal,
+  D as LLMPlugin,
+  I as LLM_CLIENT_SYMBOL,
+  K as LLM_CONFIG_SYMBOL,
+  Y as LLM_KEYSTORE_SYMBOL,
+  g as LocalStorageAdapter,
   x as MemoryStorageAdapter,
-  _ as PROVIDERS,
-  k as ProviderSelector,
-  R as StoredKeysManager,
-  L as configStore,
-  I as createDefaultConfig,
+  C as PROVIDERS,
+  b as ProviderSelector,
+  q as StoredKeysManager,
+  A as calculateCost,
+  v as clearPricingOverrides,
+  a as configStore,
+  N as createDefaultConfig,
   r as createLLM,
-  C as createProvider,
-  O as createProviderFlexible,
-  a as keyStore,
+  _ as createProvider,
+  u as createProviderFlexible,
+  F as formatCost,
+  i as keyStore,
   t as llmClient,
-  M as maskApiKey,
-  u as registerProvider,
-  K as useLLM
+  R as lookupRates,
+  s as maskApiKey,
+  T as registerPricing,
+  O as registerProvider,
+  G as useLLM
 };

package/dist/pricing/calculate.js

@@ -0,0 +1,58 @@
+import { DEFAULT_RATES as R } from "./rates.js";
+const c = {};
+function S(t, e, n) {
+  if (typeof t != "string" || typeof e != "string" || !n)
+    throw new Error("registerPricing(provider, model, rates) requires strings and a rates object");
+  c[t] || (c[t] = {}), c[t][e] = { ...n };
+}
+function U(t, e) {
+  if (t == null) {
+    for (const n of Object.keys(c)) delete c[n];
+    return;
+  }
+  if (e == null) {
+    delete c[t];
+    return;
+  }
+  c[t] && delete c[t][e];
+}
+function b(t, e, n = null) {
+  return !t || !e ? null : r(n == null ? void 0 : n[t], e) || r(c[t], e) || r(R[t], e) || null;
+}
+function r(t, e) {
+  if (!t) return null;
+  if (t[e]) return t[e];
+  let n = null;
+  for (const u of Object.keys(t))
+    e.startsWith(u) && (n == null || u.length > n.length) && (n = u);
+  return n ? t[n] : null;
+}
+function $(t, { provider: e, model: n, pricing: u = null } = {}) {
+  if (!t) return null;
+  const s = b(e, n, u);
+  if (!s) return null;
+  const T = t.inputTokens ?? 0, p = t.outputTokens ?? 0, i = t.cachedInputTokens ?? 0, f = t.cacheCreationInputTokens ?? 0, _ = Math.max(0, T - i - f), o = s.input ?? 0, y = s.output ?? 0, C = s.cachedInput ?? o, I = s.cacheCreation ?? o, l = _ * o / 1e6, a = i * C / 1e6, h = f * I / 1e6, k = p * y / 1e6;
+  return {
+    total: l + a + h + k,
+    input: l,
+    cachedInput: a,
+    cacheCreation: h,
+    output: k,
+    currency: "USD",
+    rates: s
+  };
+}
+function g(t, { currency: e = "USD" } = {}) {
+  if (t == null || Number.isNaN(t)) return "—";
+  const n = e === "USD" ? "$" : "";
+  if (t === 0) return `${n}0.00`;
+  const u = Math.abs(t), s = u >= 1 ? 2 : u >= 0.01 ? 4 : 6;
+  return `${n}${t.toFixed(s)}`;
+}
+export {
+  $ as calculateCost,
+  U as clearPricingOverrides,
+  g as formatCost,
+  b as lookupRates,
+  S as registerPricing
+};

package/dist/pricing/index.js

@@ -0,0 +1,10 @@
+import { DEFAULT_RATES as o } from "./rates.js";
+import { calculateCost as i, clearPricingOverrides as a, formatCost as c, lookupRates as s, registerPricing as l } from "./calculate.js";
+export {
+  o as DEFAULT_RATES,
+  i as calculateCost,
+  a as clearPricingOverrides,
+  c as formatCost,
+  s as lookupRates,
+  l as registerPricing
+};

package/dist/pricing/rates.js

@@ -0,0 +1,88 @@
+const t = {
+  openai: {
+    // Flagship + workhorse (April–May 2026 lineup)
+    "gpt-5.5-pro": { input: 5, output: 30, cachedInput: 0.5 },
+    "gpt-5.5": { input: 5, output: 30, cachedInput: 0.5 },
+    "gpt-5.4-pro": { input: 30, output: 180 },
+    "gpt-5.4": { input: 2.5, output: 15, cachedInput: 0.25 },
+    "gpt-5.4-mini": { input: 0.75, output: 4.5, cachedInput: 0.075 },
+    "gpt-5.4-nano": { input: 0.2, output: 1.25, cachedInput: 0.02 },
+    // GPT-5.x family — still widely deployed
+    "gpt-5.3": { input: 1.75, output: 14, cachedInput: 0.175 },
+    "gpt-5.2-pro": { input: 10.5, output: 84 },
+    "gpt-5.2": { input: 1.75, output: 14, cachedInput: 0.175 },
+    "gpt-5.1": { input: 0.625, output: 5, cachedInput: 0.125 },
+    "gpt-5-chat": { input: 1.25, output: 10, cachedInput: 0.125 },
+    "gpt-5": { input: 0.625, output: 5, cachedInput: 0.125 },
+    "gpt-5-mini": { input: 0.25, output: 2, cachedInput: 0.025 },
+    "gpt-5-nano": { input: 0.05, output: 0.4, cachedInput: 5e-3 },
+    // Reasoning models
+    "o4-mini": { input: 1.1, output: 4.4, cachedInput: 0.275 },
+    o3: { input: 2, output: 8, cachedInput: 0.5 },
+    "o3-mini": { input: 1.1, output: 4.4, cachedInput: 0.55 },
+    // Codex variants
+    "gpt-5.1-codex": { input: 1.25, output: 10, cachedInput: 0.125 },
+    "gpt-5.1-codex-mini": { input: 0.25, output: 2, cachedInput: 0.025 },
+    "gpt-5-codex": { input: 1.25, output: 10, cachedInput: 0.125 }
+  },
+  anthropic: {
+    "claude-opus-4-7": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "claude-opus-4-6": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "claude-sonnet-4-6": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "claude-sonnet-4-5": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "claude-haiku-4-5": { input: 1, output: 5, cachedInput: 0.1, cacheCreation: 1.25 }
+  },
+  // Bedrock charges the same per-token rates as Anthropic direct for the
+  // Claude inference profiles; the model IDs differ (us.anthropic.* prefix).
+  bedrock: {
+    "us.anthropic.claude-opus-4-7": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "us.anthropic.claude-opus-4-6": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "us.anthropic.claude-sonnet-4-6": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "us.anthropic.claude-sonnet-4-5": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "us.anthropic.claude-haiku-4-5": { input: 1, output: 5, cachedInput: 0.1, cacheCreation: 1.25 }
+  },
+  gemini: {
+    // Gemini 3.x — current lineup (May 2026)
+    "gemini-3.5-flash": { input: 1.5, output: 9, cachedInput: 0.15 },
+    "gemini-3.1-pro-preview": { input: 2, output: 12, cachedInput: 0.2 },
+    "gemini-3.1-flash-lite-preview": { input: 0.25, output: 1.5, cachedInput: 0.025 },
+    "gemini-3-pro-preview": { input: 2, output: 12 },
+    "gemini-3-flash-preview": { input: 0.5, output: 3, cachedInput: 0.05 },
+    // Gemini 2.5 — still in active use
+    "gemini-2.5-pro": { input: 1, output: 10, cachedInput: 0.125 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5, cachedInput: 0.03 },
+    "gemini-2.5-flash-lite": { input: 0.1, output: 0.4, cachedInput: 0.01 }
+  },
+  grok: {
+    // Grok 4.3 (April 30, 2026 release) — current primary, 1M context
+    "grok-4.3": { input: 1.25, output: 2.5, cachedInput: 0.2 },
+    "grok-4.20-0309-reasoning": { input: 1.25, output: 2.5, cachedInput: 0.2 },
+    "grok-4.20-0309-non-reasoning": { input: 1.25, output: 2.5, cachedInput: 0.2 },
+    "grok-4.20-multi-agent-0309": { input: 1.25, output: 2.5, cachedInput: 0.2 },
+    "grok-4.20": { input: 1.25, output: 2.5, cachedInput: 0.2 },
+    "grok-build-0.1": { input: 1, output: 2 },
+    // Cheap fast tier
+    "grok-4-fast": { input: 0.2, output: 0.5 },
+    "grok-code-fast-1": { input: 0.2, output: 1.5 }
+  },
+  deepseek: {
+    "deepseek-v4-pro": { input: 0.435, output: 0.87, cachedInput: 36e-4 },
+    "deepseek-v4-flash": { input: 0.1, output: 0.2, cachedInput: 28e-4 },
+    "deepseek-v3.2": { input: 0.252, output: 0.378, cachedInput: 0.0252 },
+    "deepseek-v3.2-thinking": { input: 0.252, output: 0.378, cachedInput: 0.0252 },
+    "deepseek-chat": { input: 0.014, output: 0.028 },
+    "deepseek-reasoner": { input: 0.55, output: 2 }
+  },
+  // OpenRouter prices vary per upstream model and include their own margin —
+  // ship empty; callers can either register their own rates or use
+  // OpenRouterProvider.discoverModelsWithMetadata() (which returns pricing).
+  openrouter: {},
+  // Local inference — free at the per-token layer.
+  ollama: {},
+  "llama-server": {},
+  // Custom OpenAI-compatible endpoints: unknown by definition.
+  custom: {}
+};
+export {
+  t as DEFAULT_RATES
+};