@kitn.ai/ui 0.20.1 → 0.22.0

package/dist/wire.js

@@ -0,0 +1,1126 @@
+var z = Object.defineProperty;
+var G = (t, e, n) => e in t ? z(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var A = (t, e, n) => G(t, typeof e != "symbol" ? e + "" : e, n);
+async function* X(t) {
+  const e = t.getReader();
+  let n = !1;
+  try {
+    for (; ; ) {
+      const { value: o, done: r } = await e.read();
+      if (r) {
+        n = !0;
+        return;
+      }
+      o && (yield o);
+    }
+  } finally {
+    n || await e.cancel().catch(() => {
+    }), e.releaseLock();
+  }
+}
+function Q(t) {
+  return typeof t.getReader == "function" ? X(t) : t;
+}
+async function* V(t) {
+  const e = new TextDecoder();
+  let n = "", o = [];
+  const r = () => {
+    if (o.length === 0) return;
+    const a = o.join(`
+`);
+    return o = [], a;
+  }, s = (a) => {
+    const c = a.endsWith("\r") ? a.slice(0, -1) : a;
+    if (c === "") return "boundary";
+    if (c.startsWith(":")) return "skip";
+    if (c.startsWith("data:")) {
+      const u = c.slice(5);
+      o.push(u.startsWith(" ") ? u.slice(1) : u);
+    }
+    return "skip";
+  };
+  for await (const a of Q(t)) {
+    n += typeof a == "string" ? a : e.decode(a, { stream: !0 });
+    let c = n.indexOf(`
+`);
+    for (; c !== -1; ) {
+      const u = n.slice(0, c);
+      if (n = n.slice(c + 1), s(u) === "boundary") {
+        const d = r();
+        d !== void 0 && (yield d);
+      }
+      c = n.indexOf(`
+`);
+    }
+  }
+  n += e.decode(), n && s(n);
+  const i = r();
+  i !== void 0 && (yield i);
+}
+async function* Z(t) {
+  let e = !1;
+  for await (const n of V(t))
+    if (!e) {
+      if (n === "[DONE]") {
+        e = !0;
+        continue;
+      }
+      try {
+        yield JSON.parse(n);
+      } catch {
+      }
+    }
+}
+function E(t) {
+  const e = t.toLowerCase();
+  return e ? e.includes("bash") || e.includes("command") || e.includes("shell") || e.includes("terminal") || e.includes("exec") ? "command" : e.includes("edit") || e.includes("write") || e.includes("patch") || e.includes("replace") || e.includes("delete") ? "file-change" : e.includes("search") || e.includes("grep") || e.includes("glob") || e.includes("find") ? "search" : e.includes("fetch") || e.includes("http") || e.includes("browse") || e.includes("crawl") ? "fetch" : e.includes("mcp") ? "mcp" : e.includes("image") || e.includes("screenshot") || e.includes("vision") ? "image" : "generic" : "generic";
+}
+function O(t) {
+  const e = /* @__PURE__ */ new WeakSet(), n = (o) => {
+    if (o === null || typeof o != "object") return o;
+    if (e.has(o)) return "[circular]";
+    e.add(o);
+    const r = o, s = Array.isArray(o) ? o.map(n) : Object.fromEntries(Object.keys(r).sort().map((i) => [i, n(r[i])]));
+    return e.delete(o), s;
+  };
+  return JSON.stringify(n(t)) ?? "";
+}
+function tt(t, e) {
+  const n = t[t.length - 1];
+  return (n == null ? void 0 : n.type) === "text" ? [...t.slice(0, -1), { ...n, text: n.text + e }] : [...t, { type: "text", text: e }];
+}
+function et(t, e, n = {}) {
+  const o = n.index ?? 0, r = n.streamId, s = t.findIndex(
+    (c) => c.type === "reasoning" && (c.index ?? 0) === o && c.streamId === r
+  );
+  if (s < 0)
+    return [...t, { type: "reasoning", text: e, index: o, streamId: r, label: n.label, signature: n.signature, raw: n.raw }];
+  const i = t[s], a = {
+    ...i,
+    text: i.text + e,
+    label: n.label ?? i.label,
+    signature: n.signature ?? i.signature,
+    raw: n.raw ?? i.raw
+  };
+  return rt(i, a) ? t : [...t.slice(0, s), a, ...t.slice(s + 1)];
+}
+const nt = [
+  "type",
+  "text",
+  "index",
+  "streamId",
+  "label",
+  "signature",
+  "raw"
+], ot = {
+  type: (t, e) => t.type === e.type,
+  text: (t, e) => t.text === e.text,
+  index: (t, e) => t.index === e.index,
+  streamId: (t, e) => t.streamId === e.streamId,
+  label: (t, e) => t.label === e.label,
+  signature: (t, e) => t.signature === e.signature,
+  raw: (t, e) => t.raw === e.raw
+};
+function rt(t, e) {
+  return nt.every((n) => ot[n](t, e));
+}
+function it(t, e, n) {
+  const o = t.findIndex((i) => i.type === "tool" && i.tool.toolCallId === e);
+  if (o < 0) {
+    const i = {
+      type: n.type ?? "unknown",
+      state: n.state ?? "input-streaming",
+      ...n,
+      toolCallId: e
+    };
+    return i.kind = i.kind ?? E(i.type), [...t, { type: "tool", tool: i }];
+  }
+  const r = t[o].tool, s = { ...r, ...n, toolCallId: e };
+  return s.kind = st(r, n, s.type), s.raw === void 0 && r.raw !== void 0 && (s.raw = r.raw), ct(r, s) ? t : [...t.slice(0, o), { type: "tool", tool: s }, ...t.slice(o + 1)];
+}
+function st(t, e, n) {
+  return e.kind !== void 0 ? e.kind : t.kind === void 0 || t.kind === E(t.type) ? E(n) : t.kind;
+}
+const at = [
+  "type",
+  "state",
+  "kind",
+  "toolCallId",
+  "errorText",
+  "rawInput",
+  "raw",
+  "input",
+  "output"
+], ut = {
+  type: (t, e) => t.type === e.type,
+  state: (t, e) => t.state === e.state,
+  kind: (t, e) => t.kind === e.kind,
+  toolCallId: (t, e) => t.toolCallId === e.toolCallId,
+  errorText: (t, e) => t.errorText === e.errorText,
+  rawInput: (t, e) => t.rawInput === e.rawInput,
+  raw: (t, e) => t.raw === e.raw,
+  input: (t, e) => t.input === e.input || O(t.input) === O(e.input),
+  output: (t, e) => t.output === e.output || O(t.output) === O(e.output)
+};
+function ct(t, e) {
+  return at.every((n) => ut[n](t, e));
+}
+const dt = {
+  // OpenAI chat completions
+  stop: "stop",
+  length: "length",
+  tool_calls: "tool-calls",
+  function_call: "tool-calls",
+  content_filter: "content-filter",
+  error: "error",
+  // Anthropic Messages
+  end_turn: "stop",
+  stop_sequence: "stop",
+  max_tokens: "length",
+  tool_use: "tool-calls",
+  refusal: "content-filter",
+  pause_turn: "other"
+};
+function lt(t) {
+  if (t)
+    return dt[t] ?? "other";
+}
+const pt = (t) => ({
+  index: t.index,
+  id: t.id ?? `call_${t.index}`,
+  name: t.name,
+  argumentsText: t.argumentsText
+}), ft = (t) => ({
+  source: "custom.wire.tool_call",
+  payload: { id: t.id ?? `call_${t.index}`, name: t.name, arguments: t.argumentsText }
+});
+function gt(t, e) {
+  return t.length <= e ? t : `${t.slice(0, e)}...`;
+}
+function ht(t) {
+  const e = t.trim();
+  if (e !== "")
+    try {
+      const n = JSON.parse(e);
+      return n === null || typeof n != "object" || Array.isArray(n) ? void 0 : n;
+    } catch {
+      return;
+    }
+}
+function yt(t, e = {}) {
+  const n = /* @__PURE__ */ new Map(), o = (a) => {
+    const c = a.id, u = a.argumentsText, d = ht(u);
+    if (d) {
+      const l = O(d);
+      if (l !== a.lastInputFp) {
+        a.lastInputFp = l, t.upsertTool(c, { rawInput: u, input: d, state: "input-available" });
+        return;
+      }
+    }
+    t.upsertTool(c, { rawInput: u });
+  }, r = (a) => {
+    a.announced || (a.id ?? (a.id = `call_${a.index}`), a.announced = !0, t.upsertTool(a.id, { type: a.name || "unknown_tool", state: "input-streaming" }), a.argumentsText && o(a));
+  };
+  return { apply: (a) => {
+    const c = typeof a.index == "number" ? a.index : 0;
+    let u = n.get(c);
+    u || (u = {
+      index: c,
+      id: null,
+      name: "",
+      argumentsText: "",
+      announced: !1,
+      lastInputFp: null,
+      providerExecuted: !1
+    }, n.set(c, u)), a.id && !u.id && (u.id = a.id), a.name && (u.name += a.name), u.id && u.name && r(u), typeof a.arguments == "string" && a.arguments !== "" && (u.argumentsText += a.arguments, u.announced && o(u)), (a.output !== void 0 || a.outputError !== void 0) && (r(u), u.providerExecuted = !0, a.outputError !== void 0 ? (u.outputError = a.outputError, t.upsertTool(u.id, { state: "output-error", errorText: a.outputError })) : (u.output = a.output, t.upsertTool(u.id, { state: "output-available", output: a.output })));
+  }, settle: (a, c) => [...n.values()].sort((u, d) => u.index - d.index).map((u) => {
+    var m;
+    r(u);
+    const d = u.id, l = pt(u);
+    if (u.providerExecuted)
+      return {
+        ...l,
+        providerExecuted: !0,
+        ...u.output !== void 0 ? { output: u.output } : {},
+        ...u.outputError !== void 0 ? { error: u.outputError } : {}
+      };
+    const p = ft(u), h = u.name || "unknown_tool";
+    if (c) {
+      const y = `Stream failed before the tool call completed: ${c}`;
+      return t.upsertTool(d, {
+        type: h,
+        state: "output-error",
+        errorText: y,
+        rawInput: u.argumentsText,
+        raw: p
+      }), { ...l, error: y };
+    }
+    if (!u.name) {
+      const y = "Tool call arrived with no function name; cannot dispatch it.";
+      return t.upsertTool(d, { state: "output-error", errorText: y, raw: p }), { ...l, error: y };
+    }
+    const k = u.argumentsText.trim();
+    try {
+      const y = k === "" ? {} : JSON.parse(k);
+      if (y === null || typeof y != "object" || Array.isArray(y))
+        throw new Error("arguments must be a JSON object");
+      const T = y;
+      t.upsertTool(d, {
+        type: h,
+        state: "input-available",
+        input: T,
+        rawInput: u.argumentsText,
+        raw: p
+      });
+      const v = { ...l, input: T };
+      return (m = e.onToolCallReady) == null || m.call(e, v), v;
+    } catch (y) {
+      const v = `Malformed tool arguments${a === "length" ? " (the stream hit the token limit mid-call)" : ""}: ${y.message}. Received ${k.length} chars: ${gt(k, 160)}`;
+      return t.upsertTool(d, {
+        type: h,
+        state: "output-error",
+        errorText: v,
+        rawInput: u.argumentsText,
+        raw: p
+      }), { ...l, error: v };
+    }
+  }) };
+}
+function mt() {
+  let t = [];
+  return {
+    appendText(e) {
+      t = tt(t, e);
+    },
+    appendReasoning(e, n) {
+      t = et(t, e, { ...n, streamId: void 0 });
+    },
+    upsertTool(e, n) {
+      t = it(t, e, n);
+    },
+    addSource(e) {
+      t = [...t, { type: "source", source: e }];
+    },
+    parts: () => t
+  };
+}
+function xt(t, e) {
+  return {
+    appendText(n) {
+      t.appendText(n), e.appendText(n);
+    },
+    appendReasoning(n, o) {
+      t.appendReasoning(n, o), e.appendReasoning(n, o);
+    },
+    upsertTool(n, o) {
+      t.upsertTool(n, o), e.upsertTool(n, o);
+    },
+    addSource(n) {
+      var o, r;
+      (o = t.addSource) == null || o.call(t, n), (r = e.addSource) == null || r.call(e, n);
+    }
+  };
+}
+let bt = 0;
+const kt = () => `wire-${++bt}`;
+async function wt(t, e, n = {}) {
+  var v;
+  const o = n.reasoningLabel ?? "Thinking", r = kt(), s = mt(), i = xt(e, s), a = yt(i, n);
+  let c = "", u = "", d = 0, l = 0, p = null, h, k;
+  const m = [];
+  for await (const f of t) {
+    if (l++, f.usage && (k = { ...k, ...f.usage }), f.error) {
+      h = f.error, f.finishReason && (p = f.finishReason);
+      break;
+    }
+    if (f.text && (c += f.text, i.appendText(f.text)), f.reasoning !== void 0 || f.reasoningRaw !== void 0 || f.reasoningSignature !== void 0) {
+      const _ = f.reasoning ?? "";
+      u += _, _ !== "" && d++, i.appendReasoning(_, {
+        index: f.reasoningIndex ?? 0,
+        // Namespaces the index to THIS stream, so a later round reading into the
+        // same sink opens its own part instead of overwriting this one's `raw`.
+        streamId: r,
+        label: o,
+        ...f.reasoningRaw ? { raw: f.reasoningRaw } : {},
+        ...f.reasoningSignature ? { signature: f.reasoningSignature } : {}
+      });
+    }
+    if (f.toolCalls) for (const _ of f.toolCalls) a.apply(_);
+    if (f.sources)
+      for (const _ of f.sources)
+        m.push(_), (v = i.addSource) == null || v.call(i, _);
+    f.finishReason && (p = f.finishReason);
+  }
+  l === 0 && !h && (h = {
+    code: "empty-stream",
+    message: "The model stream produced no chunks. The response was 200 but nothing in its body parsed as a stream frame — check the endpoint really sent Content-Type: text/event-stream and that the request set stream: true. A route that forwards a provider error without its status lands here: the body is a JSON error, not SSE."
+  });
+  const y = lt(p) ?? (h ? "error" : void 0), T = a.settle(y, h == null ? void 0 : h.message);
+  return {
+    parts: s.parts(),
+    text: c,
+    reasoning: u,
+    toolCalls: T,
+    sources: m,
+    finishReason: p,
+    reasoningChunks: d,
+    chunks: l,
+    ...y ? { stopReason: y } : {},
+    ...h ? { error: h } : {},
+    ...k ? { usage: k } : {}
+  };
+}
+function x(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function b(t) {
+  return typeof t == "string" ? t : void 0;
+}
+function I(t) {
+  return typeof t == "number" ? t : void 0;
+}
+function Tt(t) {
+  if (!x(t)) return;
+  const e = {}, n = I(t.prompt_tokens);
+  n !== void 0 && (e.inputTokens = n);
+  const o = I(t.completion_tokens);
+  o !== void 0 && (e.outputTokens = o);
+  const r = I(t.total_tokens);
+  r !== void 0 && (e.totalTokens = r);
+  const s = t.completion_tokens_details;
+  if (x(s)) {
+    const c = I(s.reasoning_tokens);
+    c !== void 0 && (e.reasoningTokens = c);
+  }
+  const i = t.prompt_tokens_details;
+  if (x(i)) {
+    const c = I(i.cached_tokens);
+    c !== void 0 && (e.cachedInputTokens = c);
+  }
+  const a = I(t.cost);
+  return a !== void 0 && (e.costUsd = a), Object.keys(e).length > 0 ? e : void 0;
+}
+function vt(t, e) {
+  if (!x(t)) return;
+  const n = x(t.function) ? t.function : void 0, o = { index: I(t.index) ?? e }, r = b(t.id);
+  r && (o.id = r);
+  const s = b(n == null ? void 0 : n.name);
+  s && (o.name = s);
+  const i = b(n == null ? void 0 : n.arguments);
+  return i !== void 0 && (o.arguments = i), o;
+}
+function _t(t) {
+  let e = "";
+  for (const n of t) {
+    if (!x(n)) continue;
+    const o = b(n.text) ?? b(n.summary);
+    o && (e += o);
+  }
+  return e;
+}
+function j(t, e) {
+  for (const n of t)
+    if (x(n) && n[e] !== void 0) return n[e];
+}
+function It(t, e) {
+  const n = Array.isArray(t.reasoning_details) ? t.reasoning_details : void 0, o = b(t.reasoning), r = o !== void 0 && o !== "" ? o : void 0, s = n ? _t(n) : void 0, i = n !== void 0 && n.length > 0, a = r ?? s;
+  if (a === void 0 && !i || (e.reasoning = a ?? "", !i)) return;
+  e.reasoningRaw = { source: "openai.reasoning_details", payload: n };
+  const c = I(j(n, "index"));
+  c !== void 0 && (e.reasoningIndex = c);
+  const u = b(j(n, "signature"));
+  u !== void 0 && (e.reasoningSignature = u);
+}
+function At(t) {
+  if (!Array.isArray(t.annotations)) return [];
+  const e = [];
+  for (const n of t.annotations) {
+    if (!x(n)) continue;
+    const o = x(n.url_citation) ? n.url_citation : void 0, r = b(o == null ? void 0 : o.url);
+    if (!r) continue;
+    const s = { url: r }, i = b(o == null ? void 0 : o.title);
+    i && (s.title = i);
+    const a = b(o == null ? void 0 : o.content);
+    a && (s.snippet = a), e.push(s);
+  }
+  return e;
+}
+function Rt(t) {
+  if (!x(t)) return [];
+  const e = {}, n = t.error;
+  if (x(n)) {
+    const i = b(n.message);
+    if (i) {
+      e.error = { message: i };
+      const a = n.code;
+      (typeof a == "string" || typeof a == "number") && (e.error.code = a);
+    }
+  }
+  const o = Tt(t.usage);
+  o && (e.usage = o);
+  const r = Array.isArray(t.choices) ? t.choices : [], s = x(r[0]) ? r[0] : void 0;
+  if (s) {
+    const i = x(s.delta) ? s.delta : void 0;
+    if (i) {
+      const c = b(i.content);
+      if (c && (e.text = c), It(i, e), Array.isArray(i.tool_calls) && i.tool_calls.length > 0) {
+        const d = i.tool_calls.map((l, p) => vt(l, p)).filter((l) => l !== void 0);
+        d.length > 0 && (e.toolCalls = d);
+      }
+      const u = At(i);
+      u.length > 0 && (e.sources = u);
+    }
+    const a = b(s.finish_reason);
+    a && (e.finishReason = a);
+  }
+  return Object.keys(e).length > 0 ? [e] : [];
+}
+const Ot = {
+  id: "openai.chat-completions",
+  open() {
+    return { push: Rt };
+  }
+};
+function w(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function g(t) {
+  return typeof t == "string" ? t : void 0;
+}
+function R(t) {
+  return typeof t == "number" ? t : void 0;
+}
+function W(t) {
+  if (!w(t)) return;
+  const e = {}, n = R(t.input_tokens);
+  n !== void 0 && (e.inputTokens = n);
+  const o = R(t.output_tokens);
+  o !== void 0 && (e.outputTokens = o);
+  const r = R(t.cache_read_input_tokens);
+  return r !== void 0 && (e.cachedInputTokens = r), Object.keys(e).length > 0 ? e : void 0;
+}
+function St(t, e, n) {
+  const o = R(t.index) ?? 0, r = t.content_block;
+  if (!w(r)) return [];
+  switch (g(r.type)) {
+    case "text": {
+      e.set(o, { kind: "text", thinking: "" });
+      const s = g(r.text);
+      return s ? [{ text: s }] : [];
+    }
+    case "thinking": {
+      const s = g(r.thinking) ?? "";
+      return e.set(o, { kind: "thinking", thinking: s }), [{ reasoning: s, reasoningIndex: o }];
+    }
+    case "redacted_thinking":
+      return e.set(o, { kind: "redacted_thinking", thinking: "" }), [
+        {
+          reasoning: "",
+          reasoningIndex: o,
+          reasoningRaw: { source: "anthropic.content_block", payload: r }
+        }
+      ];
+    case "tool_use":
+    case "server_tool_use": {
+      const s = g(r.id), i = g(r.name);
+      return e.set(o, { kind: "tool_use", thinking: "" }), s && n.set(s, o), [{ toolCalls: [{ index: o, ...s ? { id: s } : {}, ...i ? { name: i } : {} }] }];
+    }
+    case "web_search_tool_result": {
+      e.set(o, { kind: "other", thinking: "" });
+      const s = g(r.tool_use_id), i = s !== void 0 ? n.get(s) : void 0;
+      if (i === void 0) return [];
+      const a = r.content;
+      return w(a) && (g(a.type) ?? "").endsWith("_error") ? [
+        {
+          toolCalls: [
+            {
+              index: i,
+              ...s ? { id: s } : {},
+              outputError: g(a.error_code) ?? "web_search_tool_result_error"
+            }
+          ]
+        }
+      ] : [
+        {
+          toolCalls: [
+            { index: i, ...s ? { id: s } : {}, output: { content: a } }
+          ]
+        }
+      ];
+    }
+    default:
+      return e.set(o, { kind: "other", thinking: "" }), [];
+  }
+}
+function $t(t, e) {
+  const n = R(t.index) ?? 0, o = t.delta;
+  if (!w(o)) return [];
+  switch (g(o.type)) {
+    case "text_delta": {
+      const r = g(o.text);
+      return r ? [{ text: r }] : [];
+    }
+    case "thinking_delta": {
+      const r = g(o.thinking) ?? "", s = e.get(n);
+      return s && (s.thinking += r), [{ reasoning: r, reasoningIndex: n }];
+    }
+    case "signature_delta": {
+      const r = g(o.signature) ?? "", s = e.get(n);
+      return s && (s.signature = (s.signature ?? "") + r), [{ reasoning: "", reasoningIndex: n, reasoningSignature: r }];
+    }
+    case "input_json_delta":
+      return [{ toolCalls: [{ index: n, arguments: g(o.partial_json) ?? "" }] }];
+    case "citations_delta": {
+      const r = o.citation;
+      if (!w(r)) return [];
+      const s = {}, i = g(r.url);
+      i && (s.url = i);
+      const a = g(r.title);
+      a && (s.title = a);
+      const c = g(r.cited_text);
+      return c && (s.snippet = c), Object.keys(s).length > 0 ? [{ sources: [s] }] : [];
+    }
+    default:
+      return [];
+  }
+}
+function Et(t, e) {
+  const n = R(t.index) ?? 0, o = e.get(n);
+  if (!o || o.kind !== "thinking") return [];
+  const r = { type: "thinking", thinking: o.thinking };
+  return o.signature !== void 0 && (r.signature = o.signature), [
+    {
+      reasoning: "",
+      reasoningIndex: n,
+      reasoningRaw: { source: "anthropic.content_block", payload: r }
+    }
+  ];
+}
+function Ct(t) {
+  const e = {}, n = t.delta;
+  if (w(n)) {
+    const r = g(n.stop_reason);
+    r && (e.finishReason = r);
+  }
+  const o = W(t.usage);
+  return o && (e.usage = o), Object.keys(e).length > 0 ? [e] : [];
+}
+function Ut(t) {
+  const e = t.error, n = w(e) ? g(e.message) : void 0, o = w(e) ? g(e.type) : void 0;
+  return [
+    {
+      error: {
+        message: n ?? "The provider sent an error frame with no message.",
+        ...o ? { code: o } : {}
+      }
+    }
+  ];
+}
+const Ft = {
+  id: "anthropic.messages",
+  open() {
+    const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+    return {
+      push(n) {
+        if (!w(n)) return [];
+        switch (g(n.type)) {
+          case "message_start": {
+            const o = n.message;
+            if (!w(o)) return [];
+            const r = W(o.usage);
+            return r ? [{ usage: r }] : [];
+          }
+          case "content_block_start":
+            return St(n, t, e);
+          case "content_block_delta":
+            return $t(n, t);
+          case "content_block_stop":
+            return Et(n, t);
+          case "message_delta":
+            return Ct(n);
+          case "error":
+            return Ut(n);
+          default:
+            return [];
+        }
+      }
+    };
+  }
+};
+class U extends Error {
+  constructor(n, o, r, s) {
+    super(jt(n, o, r, s));
+    A(this, "status");
+    A(this, "statusText");
+    /** The response body parsed as JSON, or undefined when it was not JSON (an
+     *  HTML error page from a proxy, most often). */
+    A(this, "body");
+    /** The raw response body, always. */
+    A(this, "bodyText");
+    Object.setPrototypeOf(this, U.prototype), this.name = "WireError", this.status = n, this.statusText = o, this.bodyText = r, this.body = s;
+  }
+}
+function Lt(t) {
+  if (typeof t != "object" || t === null) return;
+  const e = t.error;
+  if (typeof e == "string") return e;
+  if (typeof e == "object" && e !== null) {
+    const o = e.message;
+    if (typeof o == "string") return o;
+  }
+  const n = t.message;
+  return typeof n == "string" ? n : void 0;
+}
+function jt(t, e, n, o) {
+  const r = `Model request failed: HTTP ${t}${e ? ` ${e}` : ""}`, s = Lt(o);
+  if (s) return `${r}: ${s}`;
+  const i = n.trim().slice(0, 200);
+  return i ? `${r}: ${i}` : r;
+}
+function Mt(t) {
+  return typeof t == "object" && t !== null && "ok" in t && "status" in t && "body" in t;
+}
+async function Nt(t) {
+  const e = await t.text().catch(() => "");
+  let n;
+  try {
+    n = e ? JSON.parse(e) : void 0;
+  } catch {
+    n = void 0;
+  }
+  return new U(t.status, t.statusText, e, n);
+}
+async function Pt(t) {
+  if (!Mt(t)) return t;
+  if (!t.ok) throw await Nt(t);
+  if (!t.body)
+    throw new Error(
+      "The model response has no body to stream. Check that the request set stream: true and that nothing between you and the provider buffered it."
+    );
+  return t.body;
+}
+async function q(t, e, n) {
+  const o = await Pt(t), r = n.format.open();
+  async function* s() {
+    for await (const i of Z(o))
+      for (const a of r.push(i)) yield a;
+  }
+  return wt(s(), e, n);
+}
+function se(t, e, n = {}) {
+  return q(t, e, { ...n, format: Ot });
+}
+function ae(t, e, n = {}) {
+  return q(t, e, { ...n, format: Ft });
+}
+function ue(t, e, n) {
+  t.upsertTool(e, { state: "output-available", output: n });
+}
+function ce(t, e, n) {
+  t.upsertTool(e, { state: "output-error", errorText: n });
+}
+function de(t) {
+  let e = "";
+  return {
+    appendText(n) {
+      e += n;
+    },
+    appendReasoning: (n, o) => t.appendReasoning(n, o),
+    upsertTool: (n, o) => t.upsertTool(n, o),
+    addSource: (n) => {
+      var o;
+      return (o = t.addSource) == null ? void 0 : o.call(t, n);
+    },
+    buffered: () => e
+  };
+}
+const C = [
+  { pattern: "image/jpeg", kind: "image" },
+  { pattern: "image/png", kind: "image" },
+  { pattern: "image/gif", kind: "image" },
+  { pattern: "image/webp", kind: "image" },
+  { pattern: "application/pdf", kind: "document" },
+  { pattern: "text/*", kind: "text" },
+  { pattern: "application/json", kind: "text" },
+  { pattern: "application/xml", kind: "text" },
+  { pattern: "application/x-yaml", kind: "text" },
+  { pattern: "application/yaml", kind: "text" }
+], J = "text/plain", Dt = ["", "application/octet-stream"], F = (t) => t.trim().toLowerCase(), B = (t) => Dt.includes(t === void 0 ? "" : F(t)), Wt = (t) => {
+  if (!t.startsWith(".")) return t;
+  throw new Error(
+    `\`accept\` entry "${t}" is a file extension, and this kit takes media types only. HTML's own accept attribute does take extensions, which is exactly why this throws rather than quietly matching nothing. Use a media type instead -- "text/*" covers source files, "image/*" images, "application/pdf" PDFs, and \`encodableMediaTypes()\` is the full set. You lose nothing by dropping the extension: a file the browser cannot name is decided by decoding its bytes, which is stronger than matching its name.`
+  );
+}, qt = (t) => (typeof t == "string" ? t.split(",") : t).map(F).filter((e) => e !== "").map(Wt), M = (t) => {
+  const e = t.indexOf("/");
+  return e === -1 ? [t, ""] : [t.slice(0, e), t.slice(e + 1)];
+}, S = (t, e) => {
+  const [n, o] = M(t), [r, s] = M(e);
+  return n !== "*" && n !== r ? !1 : o === "*" || o === s;
+}, Jt = (t, e) => {
+  if (S(t, e)) return e;
+  if (S(e, t)) return t;
+};
+function le() {
+  return C.map((t) => t.pattern);
+}
+function L(t = {}) {
+  const e = t.accept === void 0 ? void 0 : qt(t.accept), n = [];
+  for (const o of C) {
+    if (e === void 0) {
+      n.push({ ...o });
+      continue;
+    }
+    for (const r of e) {
+      const s = Jt(o.pattern, r);
+      s !== void 0 && !n.some((i) => i.pattern === s) && n.push({ pattern: s, kind: o.kind });
+    }
+  }
+  return {
+    types: n.map((o) => o.pattern),
+    accept: n.map((o) => o.pattern).join(","),
+    decide(o) {
+      const r = o === void 0 ? "" : F(o);
+      if (B(r))
+        return n.some((i) => S(i.pattern, J)) ? { status: "undetermined" } : (
+          // `unsupported` rather than `filtered`, deliberately: `filtered`
+          // claims the kit COULD have encoded this file, and nobody has
+          // established what it is. Unread and unnamed, it is not a text
+          // file the filter excluded -- it is a file with no known type.
+          { status: "unsupported" }
+        );
+      const s = n.find((i) => S(i.pattern, r));
+      return s ? { status: "allowed", kind: s.kind } : C.some((i) => S(i.pattern, r)) ? { status: "filtered" } : { status: "unsupported" };
+    }
+  };
+}
+const Bt = L(), Ht = /^data:([^;,]*);base64,([\s\S]*)$/, Kt = /^([a-z][a-z0-9+.-]*):/i, N = (t) => t.map((e) => `"${e}"`).join(", ");
+function P(t) {
+  try {
+    const e = atob(t), n = new Uint8Array(e.length);
+    for (let o = 0; o < e.length; o++) n[o] = e.charCodeAt(o);
+    return { ok: !0, text: new TextDecoder("utf-8", { fatal: !0 }).decode(n), bytes: e.length };
+  } catch {
+    return { ok: !1 };
+  }
+}
+const D = (t) => t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;"), Yt = /<(\/file\s*)>/gi;
+function H(t) {
+  const e = D(t.filename ?? "attachment"), n = D(t.mediaType), o = t.text.replace(Yt, "&lt;$1&gt;");
+  return `<file name="${e}" type="${n}">
+${o}
+</file>`;
+}
+function zt(t, e = Bt) {
+  var a, c, u;
+  if (t.type === "source-document") return { status: "kit-side" };
+  const n = t.url;
+  if (n === void 0 || n === "")
+    return {
+      status: "unencodable",
+      reason: "it has no `url`, so there are no bytes and no address to send. Set `url` to a `data:` URI (read the File with FileReader.readAsDataURL before you stage it) or to an https URL the provider can fetch."
+    };
+  let o, r;
+  const s = Ht.exec(n);
+  if (s) {
+    const d = s[1].toLowerCase();
+    r = B(d) ? ((a = t.mediaType) == null ? void 0 : a.toLowerCase()) ?? d : d, o = { type: "base64", mediaType: r, data: s[2], dataUri: n };
+  } else if (/^https?:\/\//i.test(n)) {
+    const d = (c = t.mediaType) == null ? void 0 : c.toLowerCase();
+    if (d === void 0 || d === "")
+      return {
+        status: "unencodable",
+        reason: `its \`url\` is remote ("${n}") but it has no \`mediaType\`, so there is no way to tell an image from a document without fetching it -- and this layer does no I/O. Set \`mediaType\` when you stage the attachment.`
+      };
+    r = d, o = { type: "remote", url: n };
+  } else {
+    if (n.startsWith("data:"))
+      return {
+        status: "unencodable",
+        reason: "its `url` is a `data:` URI that is not base64-encoded with an explicit media type. Both APIs need `data:<media type>;base64,<data>`."
+      };
+    {
+      const d = (u = Kt.exec(n)) == null ? void 0 : u[1].toLowerCase(), l = d === "blob" ? "a `blob:` URL resolves only inside the browser tab that created it, so a model can never fetch it. Read the File with FileReader.readAsDataURL and stage the `data:` URI instead, or upload it and stage the resulting https URL" : `a "${d ?? n}" URL is not something a provider can fetch. Use a \`data:\` URI or an https URL`;
+      return { status: "unencodable", reason: `its \`url\` is "${n}": ${l}.` };
+    }
+  }
+  const i = e.decide(r);
+  if (i.status === "undetermined") {
+    if (o.type !== "base64")
+      return {
+        status: "unencodable",
+        reason: `it is at a remote URL ("${o.url}") and its media type "${r}" says nothing about the bytes -- that is the label for "arbitrary binary", so it separates an image from a document not at all. Settling it by reading the bytes would need a fetch, and this layer does no I/O. Set \`mediaType\` to what the file actually is when you stage it.`
+      };
+    const d = P(o.data);
+    return d.ok ? {
+      status: "encodable",
+      file: {
+        kind: "text",
+        mediaType: J,
+        source: o,
+        filename: t.filename,
+        text: d.text
+      }
+    } : {
+      status: "unencodable",
+      reason: `nothing names it -- ${r === "" ? "it carries no media type" : `its media type is "${r}"`}, so the only way to tell what it is was to read it -- and its bytes are not valid UTF-8, so it is binary of some unidentified kind. Neither API has an arbitrary-file block to carry that. Set \`mediaType\` if you know what it is, or hand the file to the model through a tool.`
+    };
+  }
+  if (i.status === "filtered")
+    return {
+      status: "unencodable",
+      reason: `its media type "${r}" is one this kit can encode, but your \`accept\` filter excludes it. The types you allowed are: ${N(e.types)}. Widen \`accept\` to include it, or stop staging it.`
+    };
+  if (i.status === "unsupported")
+    return {
+      status: "unencodable",
+      reason: `its media type "${r}" is not one either API accepts as message content. Supported: ${N(e.types)}. Extract the content yourself and send it as text, or hand it to the model through a tool.`
+    };
+  if (i.kind === "text") {
+    if (o.type !== "base64")
+      return {
+        status: "unencodable",
+        reason: `it is a text file at a remote URL ("${o.url}"), and text has to ride as text CONTENT -- neither API has an arbitrary-file block to point at a URL with. Reading it here would put I/O in the encoder. Fetch it yourself and stage the \`data:\` URI, or paste the contents as a text part.`
+      };
+    const d = P(o.data);
+    return d.ok ? {
+      status: "encodable",
+      file: {
+        kind: "text",
+        mediaType: r,
+        source: o,
+        filename: t.filename,
+        text: d.text
+      }
+    } : {
+      status: "unencodable",
+      reason: `its media type "${r}" says text, but its bytes are not valid UTF-8 -- so it is binary wearing a text label, and inlining it would send the model garbage. Send it under its real media type, or extract the text yourself.`
+    };
+  }
+  return {
+    status: "encodable",
+    file: { kind: i.kind, mediaType: r, source: o, filename: t.filename }
+  };
+}
+class $ extends Error {
+  constructor(n, o, r) {
+    super(n);
+    A(this, "messageId");
+    A(this, "partIndex");
+    Object.setPrototypeOf(this, $.prototype), this.name = "WireEncodeError", this.messageId = o, this.partIndex = r;
+  }
+}
+const Gt = (t) => t.type === "text", Xt = (t) => t.filter(Gt).map((e) => e.text).join("");
+function K(t, e, n, o, r, s) {
+  const i = zt(t.attachment, r);
+  if (i.status === "kit-side") return null;
+  const a = (u) => {
+    if (o === "skip") return null;
+    throw new $(
+      `Cannot encode file part ${n} of message "${e}": ${u} Pass { onUnencodableFile: 'skip' } to drop it instead of failing.`,
+      e,
+      n
+    );
+  };
+  if (i.status === "unencodable") return a(i.reason);
+  const c = s(i.file);
+  return c.ok ? c.block : a(c.reason);
+}
+const Qt = (t) => t.kind === "text" ? { ok: !0, block: { type: "text", text: H(t) } } : t.kind === "image" ? { ok: !0, block: { type: "image_url", image_url: { url: t.source.type === "base64" ? t.source.dataUri : t.source.url } } } : t.source.type === "remote" ? {
+  ok: !1,
+  reason: `it is a PDF at a remote URL ("${t.source.url}"), and a chat-completions \`file\` content part carries only \`file_id\` or \`file_data\` -- this wire has no URL form for a document. Fetch it and stage it as a \`data:\` URI, or upload it through the Files API and send \`file_id\` yourself; fetching it HERE would put I/O in the encoder. The Anthropic wire does take a remote PDF, so toAnthropicMessages accepts this same message.`
+} : {
+  ok: !0,
+  block: {
+    type: "file",
+    file: {
+      ...t.filename !== void 0 ? { filename: t.filename } : {},
+      file_data: t.source.dataUri
+    }
+  }
+}, Vt = (t) => t.kind === "text" ? { ok: !0, block: { type: "text", text: H(t) } } : {
+  ok: !0,
+  block: {
+    type: t.kind === "image" ? "image" : "document",
+    source: t.source.type === "base64" ? { type: "base64", media_type: t.source.mediaType, data: t.source.data } : { type: "url", url: t.source.url }
+  }
+}, Y = (t) => typeof t.toolCallId == "string" && t.toolCallId !== "" && (t.output !== void 0 || t.errorText !== void 0);
+function Zt(t) {
+  return t.rawInput !== void 0 && t.rawInput !== "" ? t.rawInput : t.input !== void 0 ? JSON.stringify(t.input) : "{}";
+}
+const te = (t) => ({
+  id: t.toolCallId,
+  type: "function",
+  function: { name: t.type, arguments: Zt(t) }
+}), ee = (t) => ({
+  role: "tool",
+  tool_call_id: t.toolCallId,
+  name: t.type,
+  content: t.errorText ?? JSON.stringify(t.output)
+}), ne = (t) => typeof t == "object" && t !== null && !Array.isArray(t);
+function oe(t) {
+  var s;
+  if (((s = t.raw) == null ? void 0 : s.source) !== "openai.reasoning_details") return;
+  const e = t.raw.payload;
+  if (!Array.isArray(e)) return;
+  const n = e.filter(ne), o = n.filter((i) => i.index === t.index), r = o.length > 0 ? o : n;
+  return r[r.length - 1];
+}
+function re(t) {
+  const e = oe(t);
+  if (!e) return;
+  if (e.type === "reasoning.encrypted" || typeof e.data == "string") return e;
+  if (typeof t.signature != "string" || t.signature === "") return;
+  const n = typeof e.type == "string" ? e.type : "reasoning.text", r = { type: n, [n === "reasoning.summary" ? "summary" : "text"]: t.text, signature: t.signature };
+  return typeof e.format == "string" && (r.format = e.format), typeof e.id == "string" && (r.id = e.id), e.index !== void 0 && (r.index = e.index), r;
+}
+function pe(t, e = {}) {
+  const n = e.reasoning === "include", o = e.onUnencodableFile ?? "throw", r = L({ accept: e.accept }), s = [];
+  for (const i of t) {
+    if (i.role === "user") {
+      const l = [];
+      let p = "", h = !1;
+      const k = () => {
+        p !== "" && (l.push({ type: "text", text: p }), p = "");
+      };
+      if (i.parts.forEach((m, y) => {
+        if (m.type === "text") {
+          p += m.text;
+          return;
+        }
+        if (m.type !== "file") return;
+        const T = K(m, i.id, y, o, r, Qt);
+        T && (k(), l.push(T), h = !0);
+      }), k(), !h) {
+        const m = Xt(i.parts);
+        m !== "" && s.push({ role: "user", content: m });
+        continue;
+      }
+      s.push({ role: "user", content: l });
+      continue;
+    }
+    let a = "", c = [], u = [];
+    const d = () => {
+      if (!(a === "" && c.length === 0)) {
+        s.push({
+          role: "assistant",
+          content: a === "" ? null : a,
+          ...u.length > 0 ? { reasoning_details: u } : {},
+          ...c.length > 0 ? { tool_calls: c.map(te) } : {}
+        });
+        for (const l of c) s.push(ee(l));
+        a = "", c = [], u = [];
+      }
+    };
+    for (const l of i.parts) {
+      if (l.type === "text") {
+        c.length > 0 && d(), a += l.text;
+        continue;
+      }
+      if (l.type === "reasoning") {
+        if (!n) continue;
+        c.length > 0 && d();
+        const p = re(l);
+        p && u.push(p);
+        continue;
+      }
+      l.type === "tool" && Y(l.tool) && c.push(l.tool);
+    }
+    d();
+  }
+  return s;
+}
+function fe(t, e = {}) {
+  const n = e.onUnencodableFile ?? "throw", o = L({ accept: e.accept }), r = [], s = (i) => {
+    const a = r[r.length - 1];
+    (a == null ? void 0 : a.role) === "user" ? a.content = [...a.content, ...i] : r.push({ role: "user", content: i });
+  };
+  for (const i of t) {
+    if (i.role === "user") {
+      const d = [];
+      i.parts.forEach((l, p) => {
+        if (l.type === "text") {
+          l.text !== "" && d.push({ type: "text", text: l.text });
+          return;
+        }
+        if (l.type !== "file") return;
+        const h = K(l, i.id, p, n, o, Vt);
+        h && d.push(h);
+      }), d.length > 0 && s(d);
+      continue;
+    }
+    let a = [], c = [];
+    const u = () => {
+      a.length > 0 && r.push({ role: "assistant", content: a }), c.length > 0 && s(c), a = [], c = [];
+    };
+    i.parts.forEach((d, l) => {
+      switch (d.type) {
+        case "reasoning": {
+          if (!d.raw)
+            throw new $(
+              `Cannot encode reasoning part ${l} of message "${i.id}": it has no \`raw\` payload, and Anthropic requires a thinking block to be echoed back verbatim. Rebuilding one from text plus signature is the documented 400. Produce reasoning parts with readAnthropicStream, which attaches the provider's own block, and keep \`raw\` when you persist a message.`,
+              i.id,
+              l
+            );
+          if (!d.raw.source.startsWith("anthropic."))
+            throw new $(
+              `Cannot encode reasoning part ${l} of message "${i.id}": its \`raw\` came from "${d.raw.source}", not from the Anthropic Messages format. Only a payload tagged \`anthropic.\` can be echoed back verbatim. If you are talking to an Anthropic model through an OpenAI-compatible endpoint, use toOpenAIMessages.`,
+              i.id,
+              l
+            );
+          c.length > 0 && u(), a.push(d.raw.payload);
+          break;
+        }
+        case "text": {
+          if (d.text === "") break;
+          c.length > 0 && u(), a.push({ type: "text", text: d.text });
+          break;
+        }
+        case "tool": {
+          const p = d.tool;
+          if (!Y(p)) break;
+          a.push({
+            type: "tool_use",
+            id: p.toolCallId,
+            name: p.type,
+            input: p.input ?? {}
+          }), c.push(
+            p.errorText !== void 0 ? {
+              type: "tool_result",
+              tool_use_id: p.toolCallId,
+              is_error: !0,
+              content: p.errorText
+            } : {
+              type: "tool_result",
+              tool_use_id: p.toolCallId,
+              content: JSON.stringify(p.output)
+            }
+          );
+          break;
+        }
+      }
+    }), u();
+  }
+  return r;
+}
+export {
+  $ as WireEncodeError,
+  U as WireError,
+  Ft as anthropicMessagesFormat,
+  ce as applyToolFailure,
+  ue as applyToolOutput,
+  de as bufferText,
+  wt as consumeModelStream,
+  yt as createToolCallAccumulator,
+  le as encodableMediaTypes,
+  lt as normalizeStopReason,
+  Ot as openaiChatFormat,
+  ae as readAnthropicStream,
+  q as readModelStream,
+  se as readOpenAIStream,
+  X as readableToAsyncIterable,
+  L as resolveMediaPolicy,
+  V as sseDataFrames,
+  Z as sseJson,
+  fe as toAnthropicMessages,
+  pe as toOpenAIMessages
+};