@anvaka/vue-llm 0.1.2 → 0.3.0

package/README.md

@@ -3,9 +3,10 @@
 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)
 - Vue plugin for dependency injection
 - `useLLM()` composable with reactive streaming state
 - Ready-to-use components: `ProviderSelector`, `LLMConfigModal`, `StoredKeysManager`
@@ -121,13 +122,73 @@ 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}`)
+  }
+})
+```
+
+### 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 +211,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 A {
-  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();
@@ -28,24 +41,25 @@ class A {
         temperature: t.temperature ?? 0.1,
         maxTokens: 10,
         stream: !1
-      }), o = this.provider.prepareRequest(e, n), a = await this.provider.makeRequest(o);
-      return (r = this.provider.processResponse(a).content) == null ? void 0 : r.trim();
+      }), o = this.provider.prepareRequest(e, n), l = await this.provider.makeRequest(o);
+      return (r = this.provider.processResponse(l).content) == null ? void 0 : r.trim();
     } finally {
       this.config = s, this.provider = i;
     }
   }
   _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,89 @@ class A {
   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)
+  //  2) append the assistant message to the conversation
+  //  3) if no tool calls → stop (the model is done)
+  //  4) otherwise execute each tool via `executors[name](args)` and append
+  //     a tool message per call, then loop
+  //
+  // `tools` is OpenAI-style ([{type:'function', function:{name, description, parameters}}]).
+  // Providers translate to native format. The caller passes `executors` as a
+  // `{ name -> async (args) => result }` map. Results are stringified into the
+  // tool message content (or used verbatim if the executor already returns a
+  // string).
+  //
+  // `onEvent` (optional) fires for: iter-start, text-delta, tool-call-delta,
+  // assistant-message, tool-call, tool-result, stop. Use it to drive a trace UI.
+  async runAgentLoop({
+    messages: t,
+    tools: s,
+    executors: i,
+    onEvent: r,
+    maxIters: e = 10,
+    temperature: n,
+    model: o,
+    maxTokens: l,
+    enableThinking: p
+  } = {}) {
+    if (await this.ensureInitialized(), !this.provider.hasCapability("tools"))
+      throw new Error("Configured provider does not support tools");
+    const c = t.slice();
+    let d = 0, m = null;
+    const f = { inputTokens: 0, outputTokens: 0, totalTokens: 0, cachedInputTokens: 0, cacheCreationInputTokens: 0, reasoningTokens: 0 };
+    let b = !1;
+    for (; d < e; ) {
+      d++, r && r({ type: "iter-start", iter: d });
+      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: p ?? !1,
+        requestId: this.generateRequestId()
+      }), 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 });
+      }), 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 y) {
+        r && r({ type: "tool-call", id: a.id, name: a.name, args: a.args });
+        const R = i && i[a.name];
+        let T;
+        if (!R)
+          T = `Error: unknown tool '${a.name}'`;
+        else
+          try {
+            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)}`;
+          }
+        c.push({ role: "tool", tool_call_id: a.id, content: T }), r && r({ type: "tool-result", id: a.id, name: a.name, content: T });
+      }
+    }
+    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: d, usage: g, cost: v }), { messages: c, iterations: d, stopReason: m, usage: g, cost: v };
   }
   generateRequestId() {
     return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
@@ -119,12 +212,12 @@ class A {
   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;
   }
@@ -163,11 +256,11 @@ class S {
     };
     try {
       if (this.targetNode) {
-        const h = r({ ...n, stream: !0 });
-        return await this._streamIntoTarget(e, h, s, i);
+        const p = r({ ...n, stream: !0 });
+        return await this._streamIntoTarget(e, p, s, i);
       }
-      const a = r({ ...n, stream: !1 });
-      return await this._promiseResponse(e, a, s, i);
+      const l = r({ ...n, stream: !1 });
+      return await this._promiseResponse(e, l, s, i);
     } finally {
       (o = t.cleanup) == null || o.call(t);
     }
@@ -182,13 +275,13 @@ 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 a = (((o = (n = this.client.configStore).getEnabledConfigs) == null ? void 0 : o.call(n)) || []).map((u) => u.name || `${u.provider} (${u.baseUrl})`).filter(Boolean), h = a.length ? ` Available presets: ${a.join(", ")}` : " No configured providers found.";
-      throw new Error(`Provider preset '${t}' not found.${h}`);
+      const l = (((o = (n = this.client.configStore).getEnabledConfigs) == null ? void 0 : o.call(n)) || []).map((c) => c.name || `${c.provider} (${c.baseUrl})`).filter(Boolean), p = l.length ? ` Available presets: ${l.join(", ")}` : " No configured providers found.";
+      throw new Error(`Provider preset '${t}' not found.${p}`);
     }
-    const i = I(s.provider, s);
+    const i = U(s.provider, s);
     return await i.initialize(), { provider: i, config: s, cleanup: () => {
-      var a;
-      return (a = i.cancelAllRequests) == null ? void 0 : a.call(i);
+      var l;
+      return (l = i.cancelAllRequests) == null ? void 0 : l.call(i);
     } };
   }
   _resolvePresetName() {
@@ -205,44 +298,46 @@ class S {
       }
   }
   async _streamIntoTarget(t, s, i, r) {
-    var c, m, p, f, g, d, v, b, _, w, y, k, T, q;
+    var d, 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), (d = e.setSelected) == null || d.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), (p = e.addLLMLog) == null || p.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
-    }), (f = e.setStreamingState) == null || f.call(e, !0), e._activeRequestId = s.requestId;
-    let a = "", h = null, u = 0;
+    }), (b = e.setStreamingState) == null || b.call(e, !0), e._activeRequestId = s.requestId;
+    let l = "", p = null, c = null;
     try {
-      return await i.streamRequest(t, s, (l) => {
-        var x, C, R;
-        l.content && (a = l.fullContent, (x = e.setText) == null || x.call(e, a)), (C = l.usage) != null && C.tokens && (u += l.usage.tokens), l.finishReason && (h = l.finishReason), l.done && ((R = e.setStreamingState) == null || R.call(e, !1), e._activeRequestId = null);
-      }), (g = e.addLLMLog) == null || g.call(e, (this.operationName || "streaming-request") + "-response", { requestId: s.requestId }, { content: a, usage: { tokens: u } }), h === "length" ? ((d = e.setAttribute) == null || d.call(e, "_truncated", !0), (v = e.addLog) == null || v.call(e, "Response truncated. Increase Max Tokens.", "warn", { finish_reason: "length" })) : (b = e.setAttribute) == null || b.call(e, "_truncated", !1), await ((_ = e.persistNow) == null ? void 0 : _.call(e)), e;
-    } catch (l) {
-      throw (w = e.addLLMLog) == null || w.call(e, (this.operationName || "streaming-request") + "-error", { requestId: s.requestId }, null, l), (y = e.setStreamingState) == null || y.call(e, !1), e._activeRequestId = null, (k = e.setText) == null || k.call(e, `Error: ${l.message}`), (T = e.setAttribute) == null || T.call(e, "_truncated", !1), await ((q = e.persistNow) == null ? void 0 : q.call(e)), l;
+      await i.streamRequest(t, s, (_) => {
+        var I, S;
+        _.content && (l = _.fullContent, (I = e.setText) == null || I.call(e, l)), _.fullUsage && (c = _.fullUsage), _.finishReason && (p = _.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 }), p === "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 h, u, c, m, p, f, g;
+    var p, c, d, m, f, b, g;
     const e = i.prepareRequest(t, s), n = await i.makeRequest(e), o = i.processResponse(n);
-    if ((o.finishReason || ((u = (h = n == null ? void 0 : n.choices) == null ? void 0 : h[0]) == null ? void 0 : u.finish_reason) || null) === "length")
+    if ((o.finishReason || ((c = (p = n == null ? void 0 : n.choices) == null ? void 0 : p[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 = (d = this.client.logger) == null ? void 0 : d.warn) == null || m.call(d, "Unable to mark node as truncated", { error: v });
       }
     else
       try {
         this.contextNode.setAttribute("_truncated", !1);
-      } catch (d) {
-        (f = (p = this.client.logger) == null ? void 0 : p.warn) == null || f.call(p, "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 ((g = o.content) == null ? void 0 : g.trim()) || "";
   }
 }
 export {
-  A 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,80 @@
+const t = {
+  openai: {
+    "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 },
+    "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-4o": { input: 2.5, output: 10, cachedInput: 1.25 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6, cachedInput: 0.075 },
+    "gpt-4.1": { input: 2, output: 8, cachedInput: 0.5 },
+    "gpt-4.1-mini": { input: 0.2, output: 0.8, cachedInput: 0.1 },
+    "gpt-4.1-nano": { input: 0.05, output: 0.2, cachedInput: 0.025 },
+    "gpt-4-turbo": { input: 10, output: 30 },
+    "gpt-4": { input: 30, output: 60 },
+    "gpt-3.5-turbo": { input: 0.5, output: 1 },
+    o1: { input: 15, output: 60, cachedInput: 7.5 },
+    "o1-mini": { input: 0.55, output: 2.2, cachedInput: 0.55 },
+    o3: { input: 2, output: 8, cachedInput: 0.5 },
+    "o3-mini": { input: 1.1, output: 4.4, cachedInput: 0.55 },
+    "o4-mini": { input: 1.1, output: 4.4, cachedInput: 0.275 }
+  },
+  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 },
+    "claude-3-5-sonnet": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "claude-3-5-haiku": { input: 0.8, output: 4, cachedInput: 0.08, cacheCreation: 1 },
+    "claude-3-opus": { input: 15, output: 75 },
+    "claude-3-haiku": { input: 0.25, output: 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 },
+    "us.anthropic.claude-opus-4-1": { input: 15, output: 75 }
+  },
+  gemini: {
+    "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 },
+    "gemini-2.0-flash": { input: 0.1, output: 0.4, cachedInput: 0.025 },
+    "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
+    "gemini-1.5-pro": { input: 1.25, output: 5 },
+    "gemini-1.5-flash": { input: 0.075, output: 0.3 }
+  },
+  grok: {
+    "grok-4": { input: 3, output: 15 },
+    "grok-4-fast": { input: 0.2, output: 0.5 },
+    "grok-3": { input: 3, output: 15 },
+    "grok-3-fast": { input: 5, output: 25 },
+    "grok-3-mini": { input: 0.25, output: 0.5 },
+    "grok-code-fast-1": { input: 0.2, output: 1.5 },
+    "grok-2": { input: 2, output: 10 }
+  },
+  deepseek: {
+    "deepseek-chat": { input: 0.21, output: 0.79, cachedInput: 0.13 },
+    "deepseek-reasoner": { input: 0.55, output: 2 },
+    "deepseek-v4-flash": { input: 0.1, output: 0.2, cachedInput: 28e-4 },
+    "deepseek-v4-pro": { input: 0.435, output: 0.87, cachedInput: 36e-4 }
+  },
+  // 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
+};