@anvaka/vue-llm 0.3.2 → 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

@@ -33,15 +33,30 @@ const t = {
     "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/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

@@ -11,9 +11,9 @@ const p = [
   "us.anthropic.claude-opus-4-1-20250805-v1:0"
 ];
 class A extends w {
-  prepareRequest(n, t) {
-    const r = super.prepareRequest(n, t);
-    return delete r.stream, r.anthropic_version = "bedrock-2023-05-31", r;
+  prepareRequest(r, n) {
+    const t = super.prepareRequest(r, n);
+    return delete t.stream, t.anthropic_version = "bedrock-2023-05-31", t;
   }
   buildHeaders() {
     return y.prototype.buildHeaders.call(this);
@@ -27,17 +27,17 @@ class A extends w {
   requiresAuth() {
     return !!this.config.apiKey;
   }
-  async makeRequest(n, t, r) {
-    const e = n.model, d = { ...n };
+  async makeRequest(r, n, t) {
+    const e = r.model, d = { ...r };
     delete d.model;
-    const i = `${this.config.baseUrl}/model/${encodeURIComponent(e)}/invoke`, l = t ? { signal: t } : new AbortController();
-    t || (r = r || this.generateRequestId(), this.activeRequests.set(r, l));
+    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 o = await fetch(i, {
         method: "POST",
         headers: this.buildHeaders(),
         body: JSON.stringify(d),
-        signal: l.signal || t
+        signal: l.signal || n
       });
       if (!o.ok) {
         const h = await o.text();
@@ -45,17 +45,17 @@ class A extends w {
       }
       return o.json();
     } finally {
-      !t && r && this.activeRequests.delete(r);
+      !n && t && this.activeRequests.delete(t);
     }
   }
-  async makeStreamingRequest(n, t) {
-    const r = n.model, e = { ...n };
+  async makeStreamingRequest(r, n) {
+    const t = r.model, e = { ...r };
     delete e.model;
-    const d = `${this.config.baseUrl}/model/${encodeURIComponent(r)}/invoke-with-response-stream`, i = 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: t
+      signal: n
     });
     if (!i.ok) {
       const c = await i.text();
@@ -96,11 +96,15 @@ class A extends w {
   // 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.
-  async discoverModels(n = 1e4) {
-    if (!this.config.liveModelDiscovery || !this.getModelsEndpoint())
+  // `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(n);
+      const t = await super.discoverModels(r);
       return t.length ? t : p.slice();
     } catch {
       return p.slice();
@@ -112,32 +116,32 @@ class A extends w {
   // no distinct control-plane host can be derived (custom/relative baseUrl),
   // which disables live discovery and leaves the static fallback in place.
   getModelsEndpoint() {
-    const n = this.config.baseUrl || "", t = n.replace("bedrock-runtime.", "bedrock.");
-    return !t || t === n ? null : `${t}/inference-profiles`;
+    const r = this.config.baseUrl || "", n = r.replace("bedrock-runtime.", "bedrock.");
+    return !n || n === r ? null : `${n}/inference-profiles`;
   }
   // ListInferenceProfiles returns
   //   { inferenceProfileSummaries: [{ inferenceProfileId, ... }] }
   // Keep only Anthropic Claude profiles (us.* and global.*) — those ids are
   // exactly what InvokeModel expects in the URL path.
-  parseModelsResponse(n) {
-    const t = n == null ? void 0 : n.inferenceProfileSummaries;
-    if (!Array.isArray(t)) return p.slice();
-    const r = t.map((e) => e == null ? void 0 : e.inferenceProfileId).filter((e) => typeof e == "string" && e.includes("anthropic.claude"));
-    return r.length ? r : p.slice();
+  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 {
   constructor() {
     this.buf = new Uint8Array(0), this.textDecoder = new TextDecoder();
   }
-  feed(n) {
-    if (n && n.length) {
-      const r = new Uint8Array(this.buf.length + n.length);
-      r.set(this.buf, 0), r.set(n, this.buf.length), this.buf = r;
+  feed(r) {
+    if (r && r.length) {
+      const t = new Uint8Array(this.buf.length + r.length);
+      t.set(this.buf, 0), t.set(r, this.buf.length), this.buf = t;
     }
-    const t = [];
+    const n = [];
     for (; this.buf.length >= 12; ) {
-      const r = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength), e = r.getUint32(0, !1), d = r.getUint32(4, !1);
+      const t = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength), e = t.getUint32(0, !1), d = t.getUint32(4, !1);
       if (e < 16 || e > 16 * 1024 * 1024)
         throw new Error(`Bedrock event stream: invalid frame length ${e}`);
       if (this.buf.length < e) break;
@@ -152,43 +156,43 @@ class v {
       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";
-        t.push({ kind: "error", message: `${u}: ${b}` });
+        n.push({ kind: "error", message: `${u}: ${b}` });
         continue;
       }
       if (a && typeof a.bytes == "string")
         try {
           const u = x(a.bytes), b = JSON.parse(u);
-          t.push({ kind: "event", payload: b });
+          n.push({ kind: "event", payload: b });
         } catch (u) {
-          t.push({ kind: "error", message: `Bedrock event-stream decode failed: ${u.message}` });
+          n.push({ kind: "error", message: `Bedrock event-stream decode failed: ${u.message}` });
         }
     }
-    return t;
+    return n;
   }
 }
 function k(s) {
-  const n = {}, t = new DataView(s.buffer, s.byteOffset, s.byteLength), r = new TextDecoder();
+  const r = {}, n = new DataView(s.buffer, s.byteOffset, s.byteLength), t = new TextDecoder();
   let e = 0;
   for (; e < s.length; ) {
     const d = s[e];
     if (e += 1, e + d > s.length) break;
-    const i = r.decode(s.subarray(e, e + d));
+    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 = t.getUint16(e, !1);
+      const o = n.getUint16(e, !1);
       if (e += 2, e + o > s.length) break;
-      n[i] = r.decode(s.subarray(e, e + o)), e += o;
+      r[i] = t.decode(s.subarray(e, e + o)), e += o;
     } else
       break;
   }
-  return n;
+  return r;
 }
 function x(s) {
-  const n = atob(s), t = new Uint8Array(n.length);
-  for (let r = 0; r < n.length; r++) t[r] = n.charCodeAt(r);
-  return new TextDecoder().decode(t);
+  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 {
   p as BEDROCK_CLAUDE_MODELS,

package/dist/providers/factory.js

@@ -1,14 +1,15 @@
-import { OpenAIProvider as i } from "./OpenAIProvider.js";
-import { AnthropicProvider as s } from "./AnthropicProvider.js";
-import { BedrockProvider as n } from "./BedrockProvider.js";
+import { OpenAIProvider as o } from "./OpenAIProvider.js";
+import { AnthropicProvider as n } from "./AnthropicProvider.js";
+import { BedrockProvider as i } from "./BedrockProvider.js";
+import { BedrockMantleProvider as p } from "./BedrockMantleProvider.js";
 import { GrokProvider as m } from "./GrokProvider.js";
-import { GeminiProvider as p } from "./GeminiProvider.js";
-import { OllamaProvider as u } from "./OllamaProvider.js";
+import { GeminiProvider as u } from "./GeminiProvider.js";
+import { OllamaProvider as l } from "./OllamaProvider.js";
 import { LlamaServerProvider as E } from "./LlamaServerProvider.js";
-import { OpenRouterProvider as l } from "./OpenRouterProvider.js";
-import { DeepSeekProvider as A } from "./DeepSeekProvider.js";
-import { CustomProvider as O } from "./CustomProvider.js";
-const e = {
+import { OpenRouterProvider as A } from "./OpenRouterProvider.js";
+import { DeepSeekProvider as O } from "./DeepSeekProvider.js";
+import { CustomProvider as c } from "./CustomProvider.js";
+const r = {
   OPENAI: "openai",
   ANTHROPIC: "anthropic",
   BEDROCK: "bedrock",
@@ -20,60 +21,93 @@ const e = {
   DEEPSEEK: "deepseek",
   CUSTOM: "custom"
 }, S = {
-  [e.OPENAI]: { name: "OpenAI", baseUrl: "https://api.openai.com", requiresApiKey: !0 },
-  [e.ANTHROPIC]: { name: "Anthropic", baseUrl: "https://api.anthropic.com", requiresApiKey: !0 },
-  [e.BEDROCK]: { name: "AWS Bedrock", baseUrl: "https://bedrock-runtime.us-east-1.amazonaws.com", requiresApiKey: !0 },
-  [e.GROK]: { name: "Grok", baseUrl: "https://api.x.ai", requiresApiKey: !0 },
-  [e.GEMINI]: { name: "Google Gemini", baseUrl: "https://generativelanguage.googleapis.com", requiresApiKey: !0 },
-  [e.OLLAMA]: { name: "Ollama (Native)", baseUrl: "http://localhost:11434", requiresApiKey: !1 },
-  [e.LLAMA_SERVER]: { name: "Local Llama Server", baseUrl: "http://localhost:8080", requiresApiKey: !1 },
-  [e.OPENROUTER]: { name: "OpenRouter", baseUrl: "https://openrouter.ai/api", requiresApiKey: !0 },
-  [e.DEEPSEEK]: { name: "DeepSeek", baseUrl: "https://api.deepseek.com", requiresApiKey: !0 },
-  [e.CUSTOM]: { name: "Custom OpenAI Compatible", baseUrl: "", requiresApiKey: !1 }
+  [r.OPENAI]: { name: "OpenAI", baseUrl: "https://api.openai.com", requiresApiKey: !0 },
+  [r.ANTHROPIC]: { name: "Anthropic", baseUrl: "https://api.anthropic.com", requiresApiKey: !0 },
+  [r.BEDROCK]: {
+    name: "AWS",
+    // Two backends, chosen by a UI toggle. Mantle (default) serves the whole
+    // catalog behind one model list via BedrockMantleProvider's auto-routing
+    // (Claude -> Anthropic Messages, the rest -> OpenAI Chat Completions).
+    // Bedrock is the classic Claude-only bedrock-runtime transport. `baseUrl`
+    // is derived from (backend, region) via the templates below, and
+    // `createProvider` picks the class from `config.backend`. The region list
+    // is valid on both.
+    baseUrl: "https://bedrock-mantle.us-east-1.api.aws",
+    baseUrlTemplate: "https://bedrock-mantle.{region}.api.aws",
+    defaultBackend: "mantle",
+    backends: {
+      mantle: { label: "Mantle", baseUrlTemplate: "https://bedrock-mantle.{region}.api.aws" },
+      runtime: { label: "Bedrock", baseUrlTemplate: "https://bedrock-runtime.{region}.amazonaws.com" }
+    },
+    regions: [
+      "us-east-1",
+      "us-east-2",
+      "us-west-2",
+      "eu-central-1",
+      "eu-west-1",
+      "eu-west-2",
+      "eu-north-1",
+      "eu-south-1",
+      "ap-northeast-1",
+      "ap-south-1",
+      "ap-southeast-2",
+      "ap-southeast-3",
+      "sa-east-1"
+    ],
+    defaultRegion: "us-east-1",
+    requiresApiKey: !0
+  },
+  [r.GROK]: { name: "Grok", baseUrl: "https://api.x.ai", requiresApiKey: !0 },
+  [r.GEMINI]: { name: "Google Gemini", baseUrl: "https://generativelanguage.googleapis.com", requiresApiKey: !0 },
+  [r.OLLAMA]: { name: "Ollama (Native)", baseUrl: "http://localhost:11434", requiresApiKey: !1 },
+  [r.LLAMA_SERVER]: { name: "Local Llama Server", baseUrl: "http://localhost:8080", requiresApiKey: !1 },
+  [r.OPENROUTER]: { name: "OpenRouter", baseUrl: "https://openrouter.ai/api", requiresApiKey: !0 },
+  [r.DEEPSEEK]: { name: "DeepSeek", baseUrl: "https://api.deepseek.com", requiresApiKey: !0 },
+  [r.CUSTOM]: { name: "Custom OpenAI Compatible", baseUrl: "", requiresApiKey: !1 }
 };
-function c(t, r) {
+function d(t, e) {
   switch (t) {
-    case e.OPENAI:
-      return new i(r);
-    case e.ANTHROPIC:
-      return new s(r);
-    case e.BEDROCK:
-      return new n(r);
-    case e.GROK:
-      return new m(r);
-    case e.GEMINI:
-      return new p(r);
-    case e.OLLAMA:
-      return new u(r);
-    case e.LLAMA_SERVER:
-      return new E(r);
-    case e.OPENROUTER:
-      return new l(r);
-    case e.DEEPSEEK:
-      return new A(r);
-    case e.CUSTOM:
-      return new O(r);
+    case r.OPENAI:
+      return new o(e);
+    case r.ANTHROPIC:
+      return new n(e);
+    case r.BEDROCK:
+      return (e == null ? void 0 : e.backend) === "runtime" ? new i(e) : new p(e);
+    case r.GROK:
+      return new m(e);
+    case r.GEMINI:
+      return new u(e);
+    case r.OLLAMA:
+      return new l(e);
+    case r.LLAMA_SERVER:
+      return new E(e);
+    case r.OPENROUTER:
+      return new A(e);
+    case r.DEEPSEEK:
+      return new O(e);
+    case r.CUSTOM:
+      return new c(e);
     default:
       throw new Error(`Unknown provider type: ${t}`);
   }
 }
 const a = /* @__PURE__ */ new Map();
-function b(t, r) {
-  if (typeof t != "string" || !r)
+function M(t, e) {
+  if (typeof t != "string" || !e)
     throw new Error("registerProvider requires a type string and a class reference");
-  a.set(t, r);
+  a.set(t, e);
 }
-function N(t, r) {
+function N(t, e) {
   if (a.has(t)) {
-    const o = a.get(t);
-    return new o(r);
+    const s = a.get(t);
+    return new s(e);
   }
-  return c(t, r);
+  return d(t, e);
 }
 export {
   S as DEFAULT_CONFIGS,
-  e as PROVIDERS,
-  c as createProvider,
+  r as PROVIDERS,
+  d as createProvider,
   N as createProviderFlexible,
-  b as registerProvider
+  M as registerProvider
 };