@anvaka/vue-llm 0.4.0 → 0.4.2

package/dist/providers/BaseProvider.js

@@ -1,5 +1,14 @@
-class A {
+var q = (a) => {
+  throw TypeError(a);
+};
+var P = (a, e, t) => e.has(a) || q("Cannot " + t);
+var $ = (a, e, t) => e.has(a) ? q("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(a) : e.set(a, t);
+var y = (a, e, t) => (P(a, e, "access private method"), t);
+import { samplingModeFor as I, SAMPLING_MODE as x, samplingKey as L, classifyTemperatureError as _, recordSamplingConstraint as H } from "./samplingPolicy.js";
+var h, S, v;
+class z {
   constructor(e) {
+    $(this, h);
     this.config = e, this.capabilities = /* @__PURE__ */ new Set(), this.activeRequests = /* @__PURE__ */ new Map();
   }
   async initialize() {
@@ -13,84 +22,114 @@ class A {
   processResponse(e) {
     throw new Error("processResponse must be implemented by subclass");
   }
+  // Set (or omit) `request.temperature` per the model's sampling policy. Every
+  // provider whose wire format carries a top-level temperature calls this after
+  // building the request literal, instead of hand-writing
+  // `temperature: options.temperature ?? 0.7`. Centralizes the policy so it
+  // travels across transports and stays in one place. Returns `request`.
+  applySamplingParams(e, t = {}) {
+    var i, c;
+    const n = e.model || ((i = this.config) == null ? void 0 : i.model) || "", r = t.temperature ?? ((c = this.config) == null ? void 0 : c.temperature) ?? 0.7, o = I(y(this, h, S).call(this, n), n);
+    return o === x.OMIT ? delete e.temperature : e.temperature = o === x.ONE ? 1 : r, e;
+  }
+  // Send `request` via the given closure; on a temperature-related 400, correct
+  // the request in place, retry once, and — only when that corrected retry
+  // succeeds — memoize the constraint for this (host, model). Shared by the JSON
+  // and streaming paths (and reused by BedrockProvider's URL-in-path override),
+  // so the recovery ladder lives in exactly one place. `errorLabel` prefixes the
+  // thrown message so each transport keeps its own wording. Returns the ok
+  // Response; throws on any unrecoverable error.
+  async _sendWithTemperatureRetry(e, t, n = "LLM API Error") {
+    var c;
+    let r = await e();
+    if (r.ok) return r;
+    const o = await r.text(), i = r.status === 400 ? y(this, h, v).call(this, t, o) : null;
+    if (!i) throw new Error(`${n} (${r.status}): ${o}`);
+    if (r = await e(), !r.ok)
+      throw new Error(`${n} (${r.status}): ${await r.text()}`);
+    return H(y(this, h, S).call(this, t.model || ((c = this.config) == null ? void 0 : c.model) || ""), i), r;
+  }
   async streamRequest(e, t, n) {
-    const r = this.prepareRequest(e, t), o = new AbortController(), l = t.requestId || this.generateRequestId();
-    this.activeRequests.set(l, o);
+    var T;
+    const r = this.prepareRequest(e, t), o = new AbortController(), i = t.requestId || this.generateRequestId();
+    this.activeRequests.set(i, o);
+    const c = () => o.abort();
+    t.signal && (t.signal.aborted ? o.abort() : t.signal.addEventListener("abort", c, { once: !0 }));
     try {
-      const k = (await this.makeStreamingRequest(r, o.signal)).body.getReader(), E = new TextDecoder();
-      let m = "", f = "", g = null, u = "";
-      const w = /* @__PURE__ */ new Map(), b = () => Array.from(w.values()).sort((a, s) => a.index - s.index).map((a) => {
+      const f = (await this.makeStreamingRequest(r, o.signal)).body.getReader(), D = new TextDecoder();
+      let b = "", w = "", p = null, d = "";
+      const R = /* @__PURE__ */ new Map(), k = () => Array.from(R.values()).sort((l, s) => l.index - s.index).map((l) => {
         let s = {};
-        if (a.argsText)
+        if (l.argsText)
           try {
-            s = JSON.parse(a.argsText);
+            s = JSON.parse(l.argsText);
           } catch {
-            s = { __parseError: !0, raw: a.argsText };
+            s = { __parseError: !0, raw: l.argsText };
           }
-        return { id: a.id, name: a.name, args: s };
-      }), R = (p) => {
-        if (!p.trim()) return null;
-        const a = this.parseStreamingLine(p);
-        if (!a) return null;
-        const s = this.extractStreamingContent(a);
+        return { id: l.id, name: l.name, args: s };
+      }), M = (g) => {
+        if (!g.trim()) return null;
+        const l = this.parseStreamingLine(g);
+        if (!l) return null;
+        const s = this.extractStreamingContent(l);
         if (!s) return null;
-        s.content && (m += s.content), s.thinking && (f += s.thinking), s.usage && (g = q(g, s.usage));
-        const y = Array.isArray(s.toolCallDeltas) ? s.toolCallDeltas : s.toolCallDelta ? [s.toolCallDelta] : [];
-        for (const i of y) {
-          let d = w.get(i.index);
-          d ? (i.id && (d.id = i.id), i.name && (d.name = i.name)) : (d = { index: i.index, id: i.id || null, name: i.name || "", argsText: "" }, w.set(i.index, d)), i.argsTextDelta && (d.argsText += i.argsTextDelta);
+        s.content && (b += s.content), s.thinking && (w += s.thinking), s.usage && (p = N(p, s.usage));
+        const C = Array.isArray(s.toolCallDeltas) ? s.toolCallDeltas : s.toolCallDelta ? [s.toolCallDelta] : [];
+        for (const u of C) {
+          let m = R.get(u.index);
+          m ? (u.id && (m.id = u.id), u.name && (m.name = u.name)) : (m = { index: u.index, id: u.id || null, name: u.name || "", argsText: "" }, R.set(u.index, m)), u.argsTextDelta && (m.argsText += u.argsTextDelta);
         }
-        const T = s.done || !1, C = T ? b() : null;
+        const A = s.done || !1, O = A ? k() : null;
         return n({
           content: s.content || "",
           thinking: s.thinking || "",
-          fullContent: m,
-          fullThinking: f,
-          done: T,
+          fullContent: b,
+          fullThinking: w,
+          done: A,
           usage: s.usage || null,
-          fullUsage: g,
+          fullUsage: p,
           finishReason: s.finishReason || null,
           toolCallDelta: s.toolCallDelta || null,
-          toolCalls: C
-        }), T ? "done" : null;
+          toolCalls: O
+        }), A ? "done" : null;
       };
       for (; ; ) {
-        const { done: p, value: a } = await k.read();
-        if (p) {
-          u.length > 0 && R(u);
+        const { done: g, value: l } = await f.read();
+        if (g) {
+          d.length > 0 && M(d);
           break;
         }
-        u += E.decode(a, { stream: !0 });
+        d += D.decode(l, { stream: !0 });
         let s;
-        for (; (s = u.indexOf(`
+        for (; (s = d.indexOf(`
 `)) !== -1; ) {
-          const y = u.slice(0, s);
-          if (u = u.slice(s + 1), R(y) === "done")
-            return { content: m, thinking: f, toolCalls: b(), usage: g };
+          const C = d.slice(0, s);
+          if (d = d.slice(s + 1), M(C) === "done")
+            return { content: b, thinking: w, toolCalls: k(), usage: p };
         }
       }
-      return { content: m, thinking: f, toolCalls: b(), usage: g };
-    } catch (h) {
-      throw h.name === "AbortError" ? new Error("Request cancelled") : h;
+      return { content: b, thinking: w, toolCalls: k(), usage: p };
+    } catch (E) {
+      if (E.name === "AbortError") {
+        const f = new Error("Request cancelled");
+        throw f.name = "AbortError", f;
+      }
+      throw E;
     } finally {
-      this.activeRequests.delete(l);
+      this.activeRequests.delete(i), (T = t.signal) == null || T.removeEventListener("abort", c);
     }
   }
   async makeRequest(e, t, n) {
     const r = t ? { signal: t } : new AbortController();
     t || (n = n || this.generateRequestId(), this.activeRequests.set(n, r));
     try {
-      const o = this.buildHeaders(), l = await fetch(this.getEndpoint(), {
+      const o = this.buildHeaders(), i = r.signal || t, c = () => fetch(this.getEndpoint(), {
         method: "POST",
         headers: o,
         body: JSON.stringify(e),
-        signal: r.signal || t
+        signal: i
       });
-      if (!l.ok) {
-        const h = await l.text();
-        throw new Error(`LLM API Error (${l.status}): ${h}`);
-      }
-      return l.json();
+      return (await this._sendWithTemperatureRetry(c, e)).json();
     } catch (o) {
       throw o.name === "AbortError" ? new Error("Request cancelled") : o;
     } finally {
@@ -98,17 +137,13 @@ class A {
     }
   }
   async makeStreamingRequest(e, t) {
-    const n = this.buildHeaders(), r = await fetch(this.getStreamingEndpoint(), {
+    const n = this.buildHeaders(), r = () => fetch(this.getStreamingEndpoint(), {
       method: "POST",
       headers: n,
       body: JSON.stringify(e),
       signal: t
     });
-    if (!r.ok) {
-      const o = await r.text();
-      throw new Error(`LLM API Error (${r.status}): ${o}`);
-    }
-    return r;
+    return this._sendWithTemperatureRetry(r, e);
   }
   buildHeaders() {
     const e = { "Content-Type": "application/json" };
@@ -166,8 +201,8 @@ class A {
       });
       if (clearTimeout(r), !o.ok)
         throw new Error(`Failed to fetch models: ${o.status} ${o.statusText}`);
-      const l = await o.json();
-      return this.parseModelsResponse(l);
+      const i = await o.json();
+      return this.parseModelsResponse(i);
     } catch (t) {
       throw t.name === "AbortError" ? new Error("Model discovery timeout - please check your connection") : t;
     }
@@ -179,14 +214,33 @@ class A {
     throw new Error("parseModelsResponse must be implemented by subclass");
   }
 }
-function q(c, e) {
-  if (!e) return c;
-  if (!c) return { ...e };
-  const t = { ...c }, n = ["inputTokens", "outputTokens", "totalTokens", "cachedInputTokens", "cacheCreationInputTokens", "reasoningTokens"];
+h = new WeakSet(), S = function(e) {
+  const t = this.getEndpoint();
+  let n = t || "";
+  try {
+    n = new URL(t).host;
+  } catch {
+  }
+  return L(n, e);
+}, // On a 400 whose body complains about `temperature`, correct the request in
+// place (drop it, or pin it to 1). Returns the applied SAMPLING_MODE (a truthy
+// string) if the request was adjusted and is worth retrying once, else null.
+// NOTE: this does NOT record the learned constraint — the caller does that only
+// after the corrected request actually succeeds, so a transient 400 whose retry
+// also fails can't permanently poison the memo for this (host, model).
+v = function(e, t) {
+  if (!("temperature" in e)) return null;
+  const n = _(t);
+  return n ? (n === x.OMIT ? delete e.temperature : e.temperature = 1, n) : null;
+};
+function N(a, e) {
+  if (!e) return a;
+  if (!a) return { ...e };
+  const t = { ...a }, n = ["inputTokens", "outputTokens", "totalTokens", "cachedInputTokens", "cacheCreationInputTokens", "reasoningTokens"];
   for (const r of n)
-    e[r] != null && (t[r] = c[r] != null ? Math.max(c[r], e[r]) : e[r]);
+    e[r] != null && (t[r] = a[r] != null ? Math.max(a[r], e[r]) : e[r]);
   return e.raw && (t.raw = e.raw), t.totalTokens == null && t.inputTokens != null && t.outputTokens != null && (t.totalTokens = t.inputTokens + t.outputTokens), t;
 }
 export {
-  A as BaseProvider
+  z as BaseProvider
 };

package/dist/providers/BedrockMantleProvider.js

@@ -1,10 +1,11 @@
-import { BaseProvider as d } from "./BaseProvider.js";
-import { OpenAIProvider as h } from "./OpenAIProvider.js";
+import { BaseProvider as h } from "./BaseProvider.js";
+import { OpenAIProvider as d } from "./OpenAIProvider.js";
 import { AnthropicProvider as f } from "./AnthropicProvider.js";
-const l = [
+const u = [
   "anthropic.claude-opus-4-8",
   "anthropic.claude-opus-4-7",
   "anthropic.claude-sonnet-5",
+  "anthropic.claude-fable-5",
   "anthropic.claude-haiku-4-5"
 ];
 function _(s) {
@@ -33,7 +34,7 @@ class b extends f {
     return delete e["anthropic-dangerous-direct-browser-access"], e;
   }
 }
-class R extends h {
+class R extends d {
   // /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).
@@ -45,7 +46,7 @@ class R extends h {
   }
 }
 const k = 16;
-class p extends d {
+class p extends h {
   constructor(e, t) {
     super(e), this._apiPath = t || "/v1/responses";
   }
@@ -61,31 +62,31 @@ class p extends d {
     this.capabilities.add("tools"), (e.includes("gpt-5") || e.includes("codex") || /(^|\.)o[13]/.test(e)) && this.capabilities.add("thinking");
   }
   prepareRequest(e, t) {
-    const r = {
+    const a = {
       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;
+    }, o = x(t.tools);
+    return o && (a.tools = o), a;
   }
   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 = {
+    const a = [];
+    for (const i of e.output || [])
+      if (i.type === "message")
+        for (const r of i.content || []) r.type === "output_text" && (t += r.text || "");
+      else if (i.type === "reasoning")
+        for (const r of i.content || []) r.type === "reasoning_text" && (n += r.text || "");
+      else i.type === "function_call" && a.push({ id: i.call_id || i.id, name: i.name, args: A(i.arguments) });
+    const o = {
       content: t,
-      usage: u(e.usage),
+      usage: l(e.usage),
       finishReason: c(e.status)
     };
-    return n && (i.thinking = n), r.length && (i.toolCalls = r), i;
+    return n && (o.thinking = n), a.length && (o.toolCalls = a), o;
   }
   // Responses streams plain `data: {json}` SSE (no [DONE]); events carry a
   // `type`. AnthropicProvider/OpenAIProvider use the same `data: ` line format.
@@ -100,7 +101,7 @@ class p extends d {
     }
   }
   extractStreamingContent(e) {
-    var t, n, r, i;
+    var t, n, a, o;
     if (e.done) return { done: !0 };
     switch (e.type) {
       case "response.output_text.delta":
@@ -112,22 +113,22 @@ class p extends d {
       // 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;
+        const i = e.item;
+        return i && i.type === "function_call" ? { content: "", done: !1, toolCallDelta: { index: e.output_index ?? 0, id: i.call_id, name: i.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) };
+        return { done: !0, usage: l((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) };
+        return { done: !0, usage: l((a = e.response) == null ? void 0 : a.usage), finishReason: c((o = e.response) == null ? void 0 : o.status) };
       default:
         return null;
     }
   }
 }
-class S extends d {
+class S extends h {
   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();
   }
@@ -145,13 +146,19 @@ class S extends d {
   _active() {
     return this._order(this.config.model)[0];
   }
+  // Detect on EVERY sub, not just the active one. _active() is not stable: the
+  // first successful request caches its winning transport in _resolved, which
+  // re-points _order() — and so _active() — at a sub that initialize() never
+  // touched. Its capability set would still be the empty one from the ctor, so
+  // hasCapability('tools') would answer false for a model that had just
+  // finished calling tools, and the NEXT agent turn would refuse to start.
+  // These detectCapabilities are pure id matching with no network, so covering
+  // all four transports costs nothing.
   async initialize() {
-    const e = this._active();
-    await e.initialize(), this.capabilities = e.capabilities;
+    await Promise.all(this._subs().map((e) => e.initialize())), this.capabilities = this._active().capabilities;
   }
   async detectCapabilities() {
-    const e = this._active();
-    await e.detectCapabilities(), this.capabilities = e.capabilities;
+    await Promise.all(this._subs().map((e) => e.detectCapabilities())), this.capabilities = this._active().capabilities;
   }
   hasCapability(e) {
     return this._active().hasCapability(e);
@@ -163,29 +170,29 @@ class S extends d {
   }
   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);
+      const { messages: a, options: o } = e.__mantle;
+      return this._runWithFallback((i) => i.makeRequest(i.prepareRequest(a, o), t, n), o == null ? void 0 : o.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);
+    return this._runWithFallback((a) => a.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))
+    let a;
+    for (const o of this._order(n))
       try {
-        const o = await e(i);
-        return this._resolved.set(n, i), o;
-      } catch (o) {
-        if (g(o)) {
-          r = o;
+        const i = await e(o);
+        return this._resolved.set(n, o), this.capabilities = this._active().capabilities, i;
+      } catch (i) {
+        if (g(i)) {
+          a = i;
           continue;
         }
-        throw y(o);
+        throw y(i);
       }
-    throw r || new Error(`No compatible Mantle API for model '${n}'`);
+    throw a || new Error(`No compatible Mantle API for model '${n}'`);
   }
   processResponse(e) {
     return this._subForShape(e).processResponse(e);
@@ -196,9 +203,9 @@ class S extends d {
   async discoverModels(e = 1e4, t) {
     try {
       const n = await this._chat.discoverModels(e, t);
-      return n.length ? n : l.slice();
+      return n.length ? n : u.slice();
     } catch {
-      return l.slice();
+      return u.slice();
     }
   }
   cancelAllRequests() {
@@ -243,11 +250,11 @@ function x(s) {
 function c(s) {
   return s === "completed" ? "stop" : s === "incomplete" ? "length" : s || null;
 }
-function u(s) {
-  var o, a;
+function l(s) {
+  var i, r;
   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;
+  const e = s.input_tokens ?? 0, t = s.output_tokens ?? 0, n = { inputTokens: e, outputTokens: t, totalTokens: s.total_tokens ?? e + t, raw: s }, a = (i = s.input_tokens_details) == null ? void 0 : i.cached_tokens, o = (r = s.output_tokens_details) == null ? void 0 : r.reasoning_tokens;
+  return a != null && (n.cachedInputTokens = a), o != null && (n.reasoningTokens = o), n;
 }
 function A(s) {
   if (!s) return {};
@@ -258,8 +265,8 @@ function A(s) {
   }
 }
 export {
-  l as BEDROCK_MANTLE_CLAUDE_MODELS,
+  u as BEDROCK_MANTLE_CLAUDE_MODELS,
   S as BedrockMantleProvider,
   _ as isMantleClaudeModel,
-  u as normalizeResponsesUsage
+  l as normalizeResponsesUsage
 };