@anvaka/vue-llm 0.3.1 → 0.4.0

package/README.md

@@ -3,7 +3,8 @@
 Browser-only LLM client + Vue 3 plugin, provider adapters, and lightweight components.
 
 ## Features
-- Provider factory with 10 built-in providers (OpenAI, Anthropic, Bedrock, Grok, Gemini, Ollama, Llama Server, OpenRouter, DeepSeek, Custom) – extend with `registerProvider()`
+- Provider factory with 10 built-in providers (OpenAI, Anthropic, AWS, Grok, Gemini, Ollama, Llama Server, OpenRouter, DeepSeek, Custom) – extend with `registerProvider()`
+- **AWS** runs on the Bedrock Mantle endpoint and exposes the entire catalog (Claude, GPT-OSS, Qwen, Mistral, Gemma, …) from one model list — each request is routed to the right API surface automatically (Claude → Anthropic Messages, everything else → OpenAI Chat Completions)
 - 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)

package/dist/pricing/rates.js

@@ -26,20 +26,37 @@ const t = {
     "gpt-5-codex": { input: 1.25, output: 10, cachedInput: 0.125 }
   },
   anthropic: {
+    "claude-opus-4-8": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
     "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 charges the same per-token rates as Anthropic direct for the Claude
+  // models; only the id form differs by backend. bedrock-runtime uses the
+  // cross-region inference profiles (us.anthropic.*); bedrock-mantle uses the
+  // Anthropic-native ids (anthropic.claude-*-v1). Both backends share this
+  // provider type ('bedrock'), so both id forms live here. Keys omit any -v1
+  // suffix so lookupRates' prefix match catches versioned ids.
   bedrock: {
+    "us.anthropic.claude-opus-4-8": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
     "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-haiku-4-5": { input: 1, output: 5, cachedInput: 0.1, cacheCreation: 1.25 },
+    // bedrock-mantle ids
+    "anthropic.claude-opus-4-8": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "anthropic.claude-opus-4-7": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "anthropic.claude-opus-4-6": { input: 5, output: 25, cachedInput: 0.5, cacheCreation: 6.25 },
+    "anthropic.claude-sonnet-5": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "anthropic.claude-sonnet-4-6": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "anthropic.claude-sonnet-4-5": { input: 3, output: 15, cachedInput: 0.3, cacheCreation: 3.75 },
+    "anthropic.claude-haiku-4-5": { input: 1, output: 5, cachedInput: 0.1, cacheCreation: 1.25 },
+    // OpenAI frontier via /openai/v1/responses (usage billed on input/output tokens)
+    "openai.gpt-5.5": { input: 5, output: 30, cachedInput: 0.5 },
+    "openai.gpt-5.4": { input: 5, output: 30, cachedInput: 0.5 }
   },
   gemini: {
     // Gemini 3.x — current lineup (May 2026)

package/dist/providers/AnthropicProvider.js

@@ -1,19 +1,19 @@
 import { BaseProvider as g } from "./BaseProvider.js";
-class C extends g {
+class b extends g {
   async detectCapabilities() {
     var t, e, o, s;
     ((t = this.config.model) != null && t.includes("claude-3") || (e = this.config.model) != null && e.includes("claude-sonnet") || (o = this.config.model) != null && o.includes("claude-opus") || (s = this.config.model) != null && s.includes("claude-haiku")) && (this.capabilities.add("vision"), this.capabilities.add("tools"));
   }
   prepareRequest(t, e) {
-    const o = _(t), s = e.model || this.config.model || "claude-3-sonnet-20240229", r = {
+    const o = m(t), s = e.model || this.config.model || "claude-3-sonnet-20240229", r = {
       model: s,
       max_tokens: e.maxTokens || 1e3,
       messages: o,
       stream: e.stream || !1
     };
-    s.includes("claude-opus-4-7") || (r.temperature = e.temperature ?? 0.7);
+    _(s) || (r.temperature = e.temperature ?? 0.7);
     const c = t.find((i) => i.role === "system");
-    return c && (r.system = c.content), e.tools && this.capabilities.has("tools") && (r.tools = m(e.tools), e.tool_choice && (r.tool_choice = e.tool_choice)), this.promptCachingEnabled(e) && y(r, e), r;
+    return c && (r.system = c.content), e.tools && this.capabilities.has("tools") && (r.tools = y(e.tools), e.tool_choice && (r.tool_choice = e.tool_choice)), this.promptCachingEnabled(e) && k(r, e), r;
   }
   // Prompt caching is on by default for the Claude/Anthropic-family path
   // (Bedrock inherits this method) because it's strictly cheaper and degrades
@@ -106,6 +106,9 @@ class C extends g {
     return ((e = t.data) == null ? void 0 : e.map((o) => o.id)) || [];
   }
 }
+function _(n) {
+  return /claude-opus-4-[789]/.test(n);
+}
 function h(n) {
   if (!n) return null;
   const t = String(n).toLowerCase();
@@ -116,7 +119,7 @@ function f(n) {
   const t = n.input_tokens ?? 0, e = n.cache_read_input_tokens ?? 0, o = n.cache_creation_input_tokens ?? 0, r = n.input_tokens != null || n.cache_read_input_tokens != null || n.cache_creation_input_tokens != null ? t + e + o : 0, c = n.output_tokens ?? 0, i = { inputTokens: r, outputTokens: c, totalTokens: r + c, raw: n };
   return n.cache_read_input_tokens != null && (i.cachedInputTokens = e), n.cache_creation_input_tokens != null && (i.cacheCreationInputTokens = o), i;
 }
-function _(n) {
+function m(n) {
   const t = [];
   for (const e of n)
     if (e.role !== "system") {
@@ -148,7 +151,7 @@ function _(n) {
     }
   return t;
 }
-function m(n) {
+function y(n) {
   return n.map((t) => t.type === "function" && t.function ? {
     name: t.function.name,
     description: t.function.description,
@@ -156,9 +159,9 @@ function m(n) {
   } : t);
 }
 const l = { type: "ephemeral" };
-function y(n, t) {
+function k(n, t) {
   if (n.system)
-    n.system = k(n.system);
+    n.system = x(n.system);
   else if (Array.isArray(n.tools) && n.tools.length) {
     const e = n.tools.length - 1;
     n.tools[e] = { ...n.tools[e], cache_control: l };
@@ -167,12 +170,12 @@ function y(n, t) {
     const e = n.messages;
     if (Array.isArray(e) && e.length) {
       const o = e[e.length - 1];
-      o.content = x(o.content);
+      o.content = A(o.content);
     }
   }
   return n;
 }
-function k(n) {
+function x(n) {
   let t;
   if (typeof n == "string")
     t = [{ type: "text", text: n }];
@@ -182,7 +185,7 @@ function k(n) {
     return n;
   return t[t.length - 1] = { ...t[t.length - 1], cache_control: l }, t;
 }
-function x(n) {
+function A(n) {
   if (typeof n == "string")
     return [{ type: "text", text: n, cache_control: l }];
   if (Array.isArray(n) && n.length) {
@@ -192,6 +195,7 @@ function x(n) {
   return n;
 }
 export {
-  C as AnthropicProvider,
-  f as normalizeAnthropicUsage
+  b as AnthropicProvider,
+  f as normalizeAnthropicUsage,
+  _ as samplingParamsRemoved
 };

package/dist/providers/BedrockMantleProvider.js

@@ -0,0 +1,265 @@
+import { BaseProvider as d } from "./BaseProvider.js";
+import { OpenAIProvider as h } from "./OpenAIProvider.js";
+import { AnthropicProvider as f } from "./AnthropicProvider.js";
+const l = [
+  "anthropic.claude-opus-4-8",
+  "anthropic.claude-opus-4-7",
+  "anthropic.claude-sonnet-5",
+  "anthropic.claude-haiku-4-5"
+];
+function _(s) {
+  return typeof s == "string" && s.includes("anthropic.claude");
+}
+function m(s) {
+  return typeof s == "string" && (/openai\.gpt-5/.test(s) || /codex/.test(s));
+}
+function g(s) {
+  return /does not support the '[^']*' API/i.test((s == null ? void 0 : s.message) || "");
+}
+function y(s) {
+  const e = (s == null ? void 0 : s.message) || "";
+  if (/not available for this account|Berm is not enabled|access_denied|permission_(error|denied)/i.test(e)) {
+    const t = new Error(`This model isn't enabled for your AWS account — request access in the Amazon Bedrock console, then try again. (${e})`);
+    return t.cause = s, t;
+  }
+  return s;
+}
+class b extends f {
+  getApiPath() {
+    return "/anthropic/v1/messages";
+  }
+  buildHeaders() {
+    const e = super.buildHeaders();
+    return delete e["anthropic-dangerous-direct-browser-access"], e;
+  }
+}
+class R extends h {
+  // /v1/chat/completions + Bearer + /v1/models are inherited. Only discovery
+  // differs: list EVERY available model so the single dropdown offers the whole
+  // catalog (the router, not this class, decides each model's transport).
+  async detectCapabilities() {
+    await super.detectCapabilities(), this.capabilities.add("tools");
+  }
+  parseModelsResponse(e) {
+    return ((e == null ? void 0 : e.data) || []).filter((t) => t && typeof t.id == "string" && (t.status == null || t.status === "available")).map((t) => t.id).sort();
+  }
+}
+const k = 16;
+class p extends d {
+  constructor(e, t) {
+    super(e), this._apiPath = t || "/v1/responses";
+  }
+  getApiPath() {
+    return this._apiPath;
+  }
+  requiresAuth() {
+    return !!this.config.apiKey;
+  }
+  // Bearer (BaseProvider default)
+  async detectCapabilities() {
+    const e = (this.config.model || "").toLowerCase();
+    this.capabilities.add("tools"), (e.includes("gpt-5") || e.includes("codex") || /(^|\.)o[13]/.test(e)) && this.capabilities.add("thinking");
+  }
+  prepareRequest(e, t) {
+    const r = {
+      model: t.model || this.config.model,
+      input: v(e),
+      // The Responses API rejects max_output_tokens < 16 (Chat Completions and
+      // Messages accept less), so clamp — e.g. testConnection sends 10.
+      max_output_tokens: Math.max(k, t.maxTokens || 1e3),
+      stream: t.stream || !1
+    }, i = x(t.tools);
+    return i && (r.tools = i), r;
+  }
+  processResponse(e) {
+    let t = "", n = "";
+    const r = [];
+    for (const o of e.output || [])
+      if (o.type === "message")
+        for (const a of o.content || []) a.type === "output_text" && (t += a.text || "");
+      else if (o.type === "reasoning")
+        for (const a of o.content || []) a.type === "reasoning_text" && (n += a.text || "");
+      else o.type === "function_call" && r.push({ id: o.call_id || o.id, name: o.name, args: A(o.arguments) });
+    const i = {
+      content: t,
+      usage: u(e.usage),
+      finishReason: c(e.status)
+    };
+    return n && (i.thinking = n), r.length && (i.toolCalls = r), i;
+  }
+  // Responses streams plain `data: {json}` SSE (no [DONE]); events carry a
+  // `type`. AnthropicProvider/OpenAIProvider use the same `data: ` line format.
+  parseStreamingLine(e) {
+    if (!e.startsWith("data: ")) return null;
+    const t = e.slice(6).trim();
+    if (t === "[DONE]") return { done: !0 };
+    try {
+      return JSON.parse(t);
+    } catch {
+      return null;
+    }
+  }
+  extractStreamingContent(e) {
+    var t, n, r, i;
+    if (e.done) return { done: !0 };
+    switch (e.type) {
+      case "response.output_text.delta":
+        return { content: e.delta || "", done: !1 };
+      case "response.reasoning_text.delta":
+        return { thinking: e.delta || "", done: !1 };
+      // A function_call item opens with output_item.added (carrying the call_id
+      // and name), then streams its JSON arguments as function_call_arguments.delta
+      // fragments. We seed id/name on `added` and stitch arg text on each delta;
+      // BaseProvider's accumulator keys them by output_index and parses at done.
+      case "response.output_item.added": {
+        const o = e.item;
+        return o && o.type === "function_call" ? { content: "", done: !1, toolCallDelta: { index: e.output_index ?? 0, id: o.call_id, name: o.name, argsTextDelta: "" } } : null;
+      }
+      case "response.function_call_arguments.delta":
+        return { content: "", done: !1, toolCallDelta: { index: e.output_index ?? 0, argsTextDelta: e.delta || "" } };
+      case "response.completed":
+        return { done: !0, usage: u((t = e.response) == null ? void 0 : t.usage), finishReason: c((n = e.response) == null ? void 0 : n.status) };
+      case "response.incomplete":
+      case "response.failed":
+        return { done: !0, usage: u((r = e.response) == null ? void 0 : r.usage), finishReason: c((i = e.response) == null ? void 0 : i.status) };
+      default:
+        return null;
+    }
+  }
+}
+class S extends d {
+  constructor(e) {
+    super(e), this._claude = new b(e), this._chat = new R(e), this._responses = new p(e, "/v1/responses"), this._openaiResponses = new p(e, "/openai/v1/responses"), this._resolved = /* @__PURE__ */ new Map();
+  }
+  _subs() {
+    return [this._claude, this._chat, this._responses, this._openaiResponses];
+  }
+  // Ordered candidate transports for a model; first that isn't rejected with
+  // "does not support" wins and is cached.
+  _order(e) {
+    const t = e || this.config.model || "";
+    if (_(t)) return [this._claude];
+    const n = this._resolved.get(t);
+    return n ? [n] : m(t) ? [this._openaiResponses, this._responses, this._chat] : [this._chat, this._responses, this._openaiResponses];
+  }
+  _active() {
+    return this._order(this.config.model)[0];
+  }
+  async initialize() {
+    const e = this._active();
+    await e.initialize(), this.capabilities = e.capabilities;
+  }
+  async detectCapabilities() {
+    const e = this._active();
+    await e.detectCapabilities(), this.capabilities = e.capabilities;
+  }
+  hasCapability(e) {
+    return this._active().hasCapability(e);
+  }
+  // Defer real preparation to makeRequest/streamRequest so we can fall back
+  // across API surfaces (a model's supported API isn't advertised anywhere).
+  prepareRequest(e, t) {
+    return { __mantle: { messages: e, options: t } };
+  }
+  async makeRequest(e, t, n) {
+    if (e && e.__mantle) {
+      const { messages: r, options: i } = e.__mantle;
+      return this._runWithFallback((o) => o.makeRequest(o.prepareRequest(r, i), t, n), i == null ? void 0 : i.model);
+    }
+    return this._subForShape(e).makeRequest(e, t, n);
+  }
+  async streamRequest(e, t, n) {
+    return this._runWithFallback((r) => r.streamRequest(e, t, n), t == null ? void 0 : t.model);
+  }
+  async _runWithFallback(e, t) {
+    const n = t || this.config.model;
+    let r;
+    for (const i of this._order(n))
+      try {
+        const o = await e(i);
+        return this._resolved.set(n, i), o;
+      } catch (o) {
+        if (g(o)) {
+          r = o;
+          continue;
+        }
+        throw y(o);
+      }
+    throw r || new Error(`No compatible Mantle API for model '${n}'`);
+  }
+  processResponse(e) {
+    return this._subForShape(e).processResponse(e);
+  }
+  _subForShape(e) {
+    return e != null && e.choices ? this._chat : e != null && e.output || e != null && e.status ? this._responses : Array.isArray(e == null ? void 0 : e.content) || e != null && e.stop_reason ? this._claude : this._active();
+  }
+  async discoverModels(e = 1e4, t) {
+    try {
+      const n = await this._chat.discoverModels(e, t);
+      return n.length ? n : l.slice();
+    } catch {
+      return l.slice();
+    }
+  }
+  cancelAllRequests() {
+    for (const e of this._subs()) e.cancelAllRequests();
+  }
+  cancelRequest(e) {
+    for (const t of this._subs()) t.cancelRequest(e);
+  }
+}
+function v(s) {
+  const e = [];
+  for (const t of s) {
+    if (t.role === "tool") {
+      e.push({ type: "function_call_output", call_id: t.tool_call_id, output: String(t.content ?? "") });
+      continue;
+    }
+    if (t.role === "assistant" && Array.isArray(t.tool_calls) && t.tool_calls.length) {
+      t.content && e.push({ role: "assistant", content: t.content });
+      for (const n of t.tool_calls)
+        e.push({
+          type: "function_call",
+          call_id: n.id,
+          name: n.name,
+          arguments: typeof n.args == "string" ? n.args : JSON.stringify(n.args || {})
+        });
+      continue;
+    }
+    e.push({ role: t.role, content: t.content });
+  }
+  return e;
+}
+function x(s) {
+  if (!(!Array.isArray(s) || !s.length))
+    return s.map((e) => {
+      if (e && e.type === "function" && e.function) {
+        const t = e.function;
+        return { type: "function", name: t.name, description: t.description, parameters: t.parameters };
+      }
+      return e;
+    });
+}
+function c(s) {
+  return s === "completed" ? "stop" : s === "incomplete" ? "length" : s || null;
+}
+function u(s) {
+  var o, a;
+  if (!s) return null;
+  const e = s.input_tokens ?? 0, t = s.output_tokens ?? 0, n = { inputTokens: e, outputTokens: t, totalTokens: s.total_tokens ?? e + t, raw: s }, r = (o = s.input_tokens_details) == null ? void 0 : o.cached_tokens, i = (a = s.output_tokens_details) == null ? void 0 : a.reasoning_tokens;
+  return r != null && (n.cachedInputTokens = r), i != null && (n.reasoningTokens = i), n;
+}
+function A(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return { __parseError: !0, raw: s };
+  }
+}
+export {
+  l as BEDROCK_MANTLE_CLAUDE_MODELS,
+  S as BedrockMantleProvider,
+  _ as isMantleClaudeModel,
+  u as normalizeResponsesUsage
+};

package/dist/providers/BedrockProvider.js

@@ -1,6 +1,7 @@
 import { BaseProvider as y } from "./BaseProvider.js";
 import { AnthropicProvider as w } from "./AnthropicProvider.js";
-const g = [
+const p = [
+  "us.anthropic.claude-opus-4-8",
   "us.anthropic.claude-opus-4-7",
   "us.anthropic.claude-sonnet-4-6",
   "us.anthropic.claude-haiku-4-5-20251001-v1:0",
@@ -9,7 +10,7 @@ const g = [
   "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
   "us.anthropic.claude-opus-4-1-20250805-v1:0"
 ];
-class R extends w {
+class A extends w {
   prepareRequest(r, n) {
     const t = super.prepareRequest(r, n);
     return delete t.stream, t.anthropic_version = "bedrock-2023-05-31", t;
@@ -29,20 +30,20 @@ class R extends w {
   async makeRequest(r, n, t) {
     const e = r.model, d = { ...r };
     delete d.model;
-    const c = `${this.config.baseUrl}/model/${encodeURIComponent(e)}/invoke`, u = n ? { signal: n } : new AbortController();
-    n || (t = t || this.generateRequestId(), this.activeRequests.set(t, u));
+    const i = `${this.config.baseUrl}/model/${encodeURIComponent(e)}/invoke`, l = n ? { signal: n } : new AbortController();
+    n || (t = t || this.generateRequestId(), this.activeRequests.set(t, l));
     try {
-      const s = await fetch(c, {
+      const o = await fetch(i, {
         method: "POST",
         headers: this.buildHeaders(),
         body: JSON.stringify(d),
-        signal: u.signal || n
+        signal: l.signal || n
       });
-      if (!s.ok) {
-        const l = await s.text();
-        throw new Error(`Bedrock API Error (${s.status}): ${l}`);
+      if (!o.ok) {
+        const h = await o.text();
+        throw new Error(`Bedrock API Error (${o.status}): ${h}`);
       }
-      return s.json();
+      return o.json();
     } finally {
       !n && t && this.activeRequests.delete(t);
     }
@@ -50,56 +51,83 @@ class R extends w {
   async makeStreamingRequest(r, n) {
     const t = r.model, e = { ...r };
     delete e.model;
-    const d = `${this.config.baseUrl}/model/${encodeURIComponent(t)}/invoke-with-response-stream`, c = await fetch(d, {
+    const d = `${this.config.baseUrl}/model/${encodeURIComponent(t)}/invoke-with-response-stream`, i = await fetch(d, {
       method: "POST",
       headers: this.buildHeaders(),
       body: JSON.stringify(e),
       signal: n
     });
-    if (!c.ok) {
-      const i = await c.text();
-      throw new Error(`Bedrock API Error (${c.status}): ${i}`);
+    if (!i.ok) {
+      const c = await i.text();
+      throw new Error(`Bedrock API Error (${i.status}): ${c}`);
     }
-    const u = c.body.getReader(), s = new v(), l = new TextEncoder(), f = new ReadableStream({
-      async pull(i) {
+    const l = i.body.getReader(), o = new v(), h = new TextEncoder(), f = new ReadableStream({
+      async pull(c) {
         try {
-          const { done: a, value: m } = await u.read();
+          const { done: a, value: g } = await l.read();
           if (a) {
-            i.close();
+            c.close();
             return;
           }
-          const p = s.feed(m);
-          for (const h of p) {
-            if (h.kind === "error") {
-              i.error(new Error(h.message));
+          const m = o.feed(g);
+          for (const u of m) {
+            if (u.kind === "error") {
+              c.error(new Error(u.message));
               return;
             }
-            i.enqueue(l.encode(`data: ${JSON.stringify(h.payload)}
+            c.enqueue(h.encode(`data: ${JSON.stringify(u.payload)}
 `));
           }
         } catch (a) {
-          i.error(a);
+          c.error(a);
         }
       },
-      cancel(i) {
+      cancel(c) {
         try {
-          u.cancel(i);
+          l.cancel(c);
         } catch {
         }
       }
     });
     return new Response(f, { status: 200, headers: { "Content-Type": "text/event-stream" } });
   }
-  // Bedrock control plane needs SigV4; Bearer auth can't list models.
-  // Return the hardcoded list so the dropdown still populates.
-  async discoverModels() {
-    return g.slice();
+  // Live discovery is opt-in via config.liveModelDiscovery. A Bedrock API key
+  // authenticates against the control plane with Bearer auth (no SigV4), and
+  // the control-plane host returns permissive CORS headers, so a browser fetch
+  // works. When disabled (default) or on any failure, fall back to the static
+  // list — existing apps keep working with zero surprise network calls.
+  // `force` is set when the user explicitly clicks Refresh in the UI; it
+  // bypasses the opt-in `liveModelDiscovery` gate so the button actually queries
+  // the control plane. Automatic loads (provider change / edit) leave `force`
+  // unset and keep the "no surprise network calls" default.
+  async discoverModels(r = 1e4, { force: n = !1 } = {}) {
+    if (!n && !this.config.liveModelDiscovery || !this.getModelsEndpoint())
+      return p.slice();
+    try {
+      const t = await super.discoverModels(r);
+      return t.length ? t : p.slice();
+    } catch {
+      return p.slice();
+    }
   }
+  // The control plane lives at the same host with the `-runtime` segment
+  // stripped: bedrock-runtime.{region}.amazonaws.com (invoke) ->
+  // bedrock.{region}.amazonaws.com (ListInferenceProfiles). Returns null when
+  // no distinct control-plane host can be derived (custom/relative baseUrl),
+  // which disables live discovery and leaves the static fallback in place.
   getModelsEndpoint() {
-    return null;
+    const r = this.config.baseUrl || "", n = r.replace("bedrock-runtime.", "bedrock.");
+    return !n || n === r ? null : `${n}/inference-profiles`;
   }
-  parseModelsResponse() {
-    return g.slice();
+  // ListInferenceProfiles returns
+  //   { inferenceProfileSummaries: [{ inferenceProfileId, ... }] }
+  // Keep only Anthropic Claude profiles (us.* and global.*) — those ids are
+  // exactly what InvokeModel expects in the URL path.
+  parseModelsResponse(r) {
+    const n = r == null ? void 0 : r.inferenceProfileSummaries;
+    if (!Array.isArray(n)) return p.slice();
+    const t = n.map((e) => e == null ? void 0 : e.inferenceProfileId).filter((e) => typeof e == "string" && e.includes("anthropic.claude"));
+    return t.length ? t : p.slice();
   }
 }
 class v {
@@ -117,56 +145,56 @@ class v {
       if (e < 16 || e > 16 * 1024 * 1024)
         throw new Error(`Bedrock event stream: invalid frame length ${e}`);
       if (this.buf.length < e) break;
-      const c = 12, u = c + d, s = u, l = e - 4, f = k(this.buf.subarray(c, u)), i = this.textDecoder.decode(this.buf.subarray(s, l));
+      const i = 12, l = i + d, o = l, h = e - 4, f = k(this.buf.subarray(i, l)), c = this.textDecoder.decode(this.buf.subarray(o, h));
       this.buf = this.buf.subarray(e);
       let a;
       try {
-        a = JSON.parse(i);
+        a = JSON.parse(c);
       } catch {
         a = null;
       }
-      const m = f[":message-type"], p = f[":exception-type"];
-      if (m === "exception" || p) {
-        const h = p || f[":event-type"] || "BedrockStreamException", b = (a == null ? void 0 : a.message) || i || "unknown error";
-        n.push({ kind: "error", message: `${h}: ${b}` });
+      const g = f[":message-type"], m = f[":exception-type"];
+      if (g === "exception" || m) {
+        const u = m || f[":event-type"] || "BedrockStreamException", b = (a == null ? void 0 : a.message) || c || "unknown error";
+        n.push({ kind: "error", message: `${u}: ${b}` });
         continue;
       }
       if (a && typeof a.bytes == "string")
         try {
-          const h = x(a.bytes), b = JSON.parse(h);
+          const u = x(a.bytes), b = JSON.parse(u);
           n.push({ kind: "event", payload: b });
-        } catch (h) {
-          n.push({ kind: "error", message: `Bedrock event-stream decode failed: ${h.message}` });
+        } catch (u) {
+          n.push({ kind: "error", message: `Bedrock event-stream decode failed: ${u.message}` });
         }
     }
     return n;
   }
 }
-function k(o) {
-  const r = {}, n = new DataView(o.buffer, o.byteOffset, o.byteLength), t = new TextDecoder();
+function k(s) {
+  const r = {}, n = new DataView(s.buffer, s.byteOffset, s.byteLength), t = new TextDecoder();
   let e = 0;
-  for (; e < o.length; ) {
-    const d = o[e];
-    if (e += 1, e + d > o.length) break;
-    const c = t.decode(o.subarray(e, e + d));
-    if (e += d, e >= o.length) break;
-    const u = o[e];
-    if (e += 1, u === 7) {
-      if (e + 2 > o.length) break;
-      const s = n.getUint16(e, !1);
-      if (e += 2, e + s > o.length) break;
-      r[c] = t.decode(o.subarray(e, e + s)), e += s;
+  for (; e < s.length; ) {
+    const d = s[e];
+    if (e += 1, e + d > s.length) break;
+    const i = t.decode(s.subarray(e, e + d));
+    if (e += d, e >= s.length) break;
+    const l = s[e];
+    if (e += 1, l === 7) {
+      if (e + 2 > s.length) break;
+      const o = n.getUint16(e, !1);
+      if (e += 2, e + o > s.length) break;
+      r[i] = t.decode(s.subarray(e, e + o)), e += o;
     } else
       break;
   }
   return r;
 }
-function x(o) {
-  const r = atob(o), n = new Uint8Array(r.length);
+function x(s) {
+  const r = atob(s), n = new Uint8Array(r.length);
   for (let t = 0; t < r.length; t++) n[t] = r.charCodeAt(t);
   return new TextDecoder().decode(n);
 }
 export {
-  g as BEDROCK_CLAUDE_MODELS,
-  R as BedrockProvider
+  p as BEDROCK_CLAUDE_MODELS,
+  A as BedrockProvider
 };