@kitn.ai/ui 0.20.1 → 0.21.0

package/dist/wire.js

@@ -0,0 +1,898 @@
+var J = Object.defineProperty;
+var F = (t, e, n) => e in t ? J(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var w = (t, e, n) => F(t, typeof e != "symbol" ? e + "" : e, n);
+async function* D(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 W(t) {
+  return typeof t.getReader == "function" ? D(t) : t;
+}
+async function* q(t) {
+  const e = new TextDecoder();
+  let n = "", o = [];
+  const r = () => {
+    if (o.length === 0) return;
+    const i = o.join(`
+`);
+    return o = [], i;
+  }, s = (i) => {
+    const c = i.endsWith("\r") ? i.slice(0, -1) : i;
+    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 i of W(t)) {
+    n += typeof i == "string" ? i : e.decode(i, { 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 l = r();
+        l !== void 0 && (yield l);
+      }
+      c = n.indexOf(`
+`);
+    }
+  }
+  n += e.decode(), n && s(n);
+  const a = r();
+  a !== void 0 && (yield a);
+}
+async function* L(t) {
+  let e = !1;
+  for await (const n of q(t))
+    if (!e) {
+      if (n === "[DONE]") {
+        e = !0;
+        continue;
+      }
+      try {
+        yield JSON.parse(n);
+      } catch {
+      }
+    }
+}
+function C(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 A(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((a) => [a, n(r[a])]));
+    return e.delete(o), s;
+  };
+  return JSON.stringify(n(t)) ?? "";
+}
+function K(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 U(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 a = t[s], i = {
+    ...a,
+    text: a.text + e,
+    label: n.label ?? a.label,
+    signature: n.signature ?? a.signature,
+    raw: n.raw ?? a.raw
+  };
+  return Y(a, i) ? t : [...t.slice(0, s), i, ...t.slice(s + 1)];
+}
+const B = [
+  "type",
+  "text",
+  "index",
+  "streamId",
+  "label",
+  "signature",
+  "raw"
+], G = {
+  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 Y(t, e) {
+  return B.every((n) => G[n](t, e));
+}
+function z(t, e, n) {
+  const o = t.findIndex((a) => a.type === "tool" && a.tool.toolCallId === e);
+  if (o < 0) {
+    const a = {
+      type: n.type ?? "unknown",
+      state: n.state ?? "input-streaming",
+      ...n,
+      toolCallId: e
+    };
+    return a.kind = a.kind ?? C(a.type), [...t, { type: "tool", tool: a }];
+  }
+  const r = t[o].tool, s = { ...r, ...n, toolCallId: e };
+  return s.kind = H(r, n, s.type), s.raw === void 0 && r.raw !== void 0 && (s.raw = r.raw), X(r, s) ? t : [...t.slice(0, o), { type: "tool", tool: s }, ...t.slice(o + 1)];
+}
+function H(t, e, n) {
+  return e.kind !== void 0 ? e.kind : t.kind === void 0 || t.kind === C(t.type) ? C(n) : t.kind;
+}
+const Q = [
+  "type",
+  "state",
+  "kind",
+  "toolCallId",
+  "errorText",
+  "rawInput",
+  "raw",
+  "input",
+  "output"
+], V = {
+  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 || A(t.input) === A(e.input),
+  output: (t, e) => t.output === e.output || A(t.output) === A(e.output)
+};
+function X(t, e) {
+  return Q.every((n) => V[n](t, e));
+}
+const Z = {
+  // 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 tt(t) {
+  if (t)
+    return Z[t] ?? "other";
+}
+const et = (t) => ({
+  index: t.index,
+  id: t.id ?? `call_${t.index}`,
+  name: t.name,
+  argumentsText: t.argumentsText
+}), nt = (t) => ({
+  source: "custom.wire.tool_call",
+  payload: { id: t.id ?? `call_${t.index}`, name: t.name, arguments: t.argumentsText }
+});
+function ot(t, e) {
+  return t.length <= e ? t : `${t.slice(0, e)}...`;
+}
+function rt(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 it(t, e = {}) {
+  const n = /* @__PURE__ */ new Map(), o = (i) => {
+    const c = i.id, u = i.argumentsText, l = rt(u);
+    if (l) {
+      const p = A(l);
+      if (p !== i.lastInputFp) {
+        i.lastInputFp = p, t.upsertTool(c, { rawInput: u, input: l, state: "input-available" });
+        return;
+      }
+    }
+    t.upsertTool(c, { rawInput: u });
+  }, r = (i) => {
+    i.announced || (i.id ?? (i.id = `call_${i.index}`), i.announced = !0, t.upsertTool(i.id, { type: i.name || "unknown_tool", state: "input-streaming" }), i.argumentsText && o(i));
+  };
+  return { apply: (i) => {
+    const c = typeof i.index == "number" ? i.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)), i.id && !u.id && (u.id = i.id), i.name && (u.name += i.name), u.id && u.name && r(u), typeof i.arguments == "string" && i.arguments !== "" && (u.argumentsText += i.arguments, u.announced && o(u)), (i.output !== void 0 || i.outputError !== void 0) && (r(u), u.providerExecuted = !0, i.outputError !== void 0 ? (u.outputError = i.outputError, t.upsertTool(u.id, { state: "output-error", errorText: i.outputError })) : (u.output = i.output, t.upsertTool(u.id, { state: "output-available", output: i.output })));
+  }, settle: (i, c) => [...n.values()].sort((u, l) => u.index - l.index).map((u) => {
+    var O;
+    r(u);
+    const l = u.id, p = et(u);
+    if (u.providerExecuted)
+      return {
+        ...p,
+        providerExecuted: !0,
+        ...u.output !== void 0 ? { output: u.output } : {},
+        ...u.outputError !== void 0 ? { error: u.outputError } : {}
+      };
+    const x = nt(u), h = u.name || "unknown_tool";
+    if (c) {
+      const g = `Stream failed before the tool call completed: ${c}`;
+      return t.upsertTool(l, {
+        type: h,
+        state: "output-error",
+        errorText: g,
+        rawInput: u.argumentsText,
+        raw: x
+      }), { ...p, error: g };
+    }
+    if (!u.name) {
+      const g = "Tool call arrived with no function name; cannot dispatch it.";
+      return t.upsertTool(l, { state: "output-error", errorText: g, raw: x }), { ...p, error: g };
+    }
+    const _ = u.argumentsText.trim();
+    try {
+      const g = _ === "" ? {} : JSON.parse(_);
+      if (g === null || typeof g != "object" || Array.isArray(g))
+        throw new Error("arguments must be a JSON object");
+      const S = g;
+      t.upsertTool(l, {
+        type: h,
+        state: "input-available",
+        input: S,
+        rawInput: u.argumentsText,
+        raw: x
+      });
+      const v = { ...p, input: S };
+      return (O = e.onToolCallReady) == null || O.call(e, v), v;
+    } catch (g) {
+      const v = `Malformed tool arguments${i === "length" ? " (the stream hit the token limit mid-call)" : ""}: ${g.message}. Received ${_.length} chars: ${ot(_, 160)}`;
+      return t.upsertTool(l, {
+        type: h,
+        state: "output-error",
+        errorText: v,
+        rawInput: u.argumentsText,
+        raw: x
+      }), { ...p, error: v };
+    }
+  }) };
+}
+function st() {
+  let t = [];
+  return {
+    appendText(e) {
+      t = K(t, e);
+    },
+    appendReasoning(e, n) {
+      t = U(t, e, { ...n, streamId: void 0 });
+    },
+    upsertTool(e, n) {
+      t = z(t, e, n);
+    },
+    addSource(e) {
+      t = [...t, { type: "source", source: e }];
+    },
+    parts: () => t
+  };
+}
+function at(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 ut = 0;
+const ct = () => `wire-${++ut}`;
+async function dt(t, e, n = {}) {
+  var v;
+  const o = n.reasoningLabel ?? "Thinking", r = ct(), s = st(), a = at(e, s), i = it(a, n);
+  let c = "", u = "", l = 0, p = 0, x = null, h, _;
+  const O = [];
+  for await (const d of t) {
+    if (p++, d.usage && (_ = { ..._, ...d.usage }), d.error) {
+      h = d.error, d.finishReason && (x = d.finishReason);
+      break;
+    }
+    if (d.text && (c += d.text, a.appendText(d.text)), d.reasoning !== void 0 || d.reasoningRaw !== void 0 || d.reasoningSignature !== void 0) {
+      const T = d.reasoning ?? "";
+      u += T, T !== "" && l++, a.appendReasoning(T, {
+        index: d.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,
+        ...d.reasoningRaw ? { raw: d.reasoningRaw } : {},
+        ...d.reasoningSignature ? { signature: d.reasoningSignature } : {}
+      });
+    }
+    if (d.toolCalls) for (const T of d.toolCalls) i.apply(T);
+    if (d.sources)
+      for (const T of d.sources)
+        O.push(T), (v = a.addSource) == null || v.call(a, T);
+    d.finishReason && (x = d.finishReason);
+  }
+  p === 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 g = tt(x) ?? (h ? "error" : void 0), S = i.settle(g, h == null ? void 0 : h.message);
+  return {
+    parts: s.parts(),
+    text: c,
+    reasoning: u,
+    toolCalls: S,
+    sources: O,
+    finishReason: x,
+    reasoningChunks: l,
+    chunks: p,
+    ...g ? { stopReason: g } : {},
+    ...h ? { error: h } : {},
+    ..._ ? { usage: _ } : {}
+  };
+}
+function y(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function m(t) {
+  return typeof t == "string" ? t : void 0;
+}
+function b(t) {
+  return typeof t == "number" ? t : void 0;
+}
+function lt(t) {
+  if (!y(t)) return;
+  const e = {}, n = b(t.prompt_tokens);
+  n !== void 0 && (e.inputTokens = n);
+  const o = b(t.completion_tokens);
+  o !== void 0 && (e.outputTokens = o);
+  const r = b(t.total_tokens);
+  r !== void 0 && (e.totalTokens = r);
+  const s = t.completion_tokens_details;
+  if (y(s)) {
+    const c = b(s.reasoning_tokens);
+    c !== void 0 && (e.reasoningTokens = c);
+  }
+  const a = t.prompt_tokens_details;
+  if (y(a)) {
+    const c = b(a.cached_tokens);
+    c !== void 0 && (e.cachedInputTokens = c);
+  }
+  const i = b(t.cost);
+  return i !== void 0 && (e.costUsd = i), Object.keys(e).length > 0 ? e : void 0;
+}
+function ft(t, e) {
+  if (!y(t)) return;
+  const n = y(t.function) ? t.function : void 0, o = { index: b(t.index) ?? e }, r = m(t.id);
+  r && (o.id = r);
+  const s = m(n == null ? void 0 : n.name);
+  s && (o.name = s);
+  const a = m(n == null ? void 0 : n.arguments);
+  return a !== void 0 && (o.arguments = a), o;
+}
+function pt(t) {
+  let e = "";
+  for (const n of t) {
+    if (!y(n)) continue;
+    const o = m(n.text) ?? m(n.summary);
+    o && (e += o);
+  }
+  return e;
+}
+function $(t, e) {
+  for (const n of t)
+    if (y(n) && n[e] !== void 0) return n[e];
+}
+function gt(t, e) {
+  const n = Array.isArray(t.reasoning_details) ? t.reasoning_details : void 0, o = m(t.reasoning), r = o !== void 0 && o !== "" ? o : void 0, s = n ? pt(n) : void 0, a = n !== void 0 && n.length > 0, i = r ?? s;
+  if (i === void 0 && !a || (e.reasoning = i ?? "", !a)) return;
+  e.reasoningRaw = { source: "openai.reasoning_details", payload: n };
+  const c = b($(n, "index"));
+  c !== void 0 && (e.reasoningIndex = c);
+  const u = m($(n, "signature"));
+  u !== void 0 && (e.reasoningSignature = u);
+}
+function ht(t) {
+  if (!Array.isArray(t.annotations)) return [];
+  const e = [];
+  for (const n of t.annotations) {
+    if (!y(n)) continue;
+    const o = y(n.url_citation) ? n.url_citation : void 0, r = m(o == null ? void 0 : o.url);
+    if (!r) continue;
+    const s = { url: r }, a = m(o == null ? void 0 : o.title);
+    a && (s.title = a);
+    const i = m(o == null ? void 0 : o.content);
+    i && (s.snippet = i), e.push(s);
+  }
+  return e;
+}
+function yt(t) {
+  if (!y(t)) return [];
+  const e = {}, n = t.error;
+  if (y(n)) {
+    const a = m(n.message);
+    if (a) {
+      e.error = { message: a };
+      const i = n.code;
+      (typeof i == "string" || typeof i == "number") && (e.error.code = i);
+    }
+  }
+  const o = lt(t.usage);
+  o && (e.usage = o);
+  const r = Array.isArray(t.choices) ? t.choices : [], s = y(r[0]) ? r[0] : void 0;
+  if (s) {
+    const a = y(s.delta) ? s.delta : void 0;
+    if (a) {
+      const c = m(a.content);
+      if (c && (e.text = c), gt(a, e), Array.isArray(a.tool_calls) && a.tool_calls.length > 0) {
+        const l = a.tool_calls.map((p, x) => ft(p, x)).filter((p) => p !== void 0);
+        l.length > 0 && (e.toolCalls = l);
+      }
+      const u = ht(a);
+      u.length > 0 && (e.sources = u);
+    }
+    const i = m(s.finish_reason);
+    i && (e.finishReason = i);
+  }
+  return Object.keys(e).length > 0 ? [e] : [];
+}
+const mt = {
+  id: "openai.chat-completions",
+  open() {
+    return { push: yt };
+  }
+};
+function k(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function f(t) {
+  return typeof t == "string" ? t : void 0;
+}
+function I(t) {
+  return typeof t == "number" ? t : void 0;
+}
+function j(t) {
+  if (!k(t)) return;
+  const e = {}, n = I(t.input_tokens);
+  n !== void 0 && (e.inputTokens = n);
+  const o = I(t.output_tokens);
+  o !== void 0 && (e.outputTokens = o);
+  const r = I(t.cache_read_input_tokens);
+  return r !== void 0 && (e.cachedInputTokens = r), Object.keys(e).length > 0 ? e : void 0;
+}
+function xt(t, e, n) {
+  const o = I(t.index) ?? 0, r = t.content_block;
+  if (!k(r)) return [];
+  switch (f(r.type)) {
+    case "text": {
+      e.set(o, { kind: "text", thinking: "" });
+      const s = f(r.text);
+      return s ? [{ text: s }] : [];
+    }
+    case "thinking": {
+      const s = f(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 = f(r.id), a = f(r.name);
+      return e.set(o, { kind: "tool_use", thinking: "" }), s && n.set(s, o), [{ toolCalls: [{ index: o, ...s ? { id: s } : {}, ...a ? { name: a } : {} }] }];
+    }
+    case "web_search_tool_result": {
+      e.set(o, { kind: "other", thinking: "" });
+      const s = f(r.tool_use_id), a = s !== void 0 ? n.get(s) : void 0;
+      if (a === void 0) return [];
+      const i = r.content;
+      return k(i) && (f(i.type) ?? "").endsWith("_error") ? [
+        {
+          toolCalls: [
+            {
+              index: a,
+              ...s ? { id: s } : {},
+              outputError: f(i.error_code) ?? "web_search_tool_result_error"
+            }
+          ]
+        }
+      ] : [
+        {
+          toolCalls: [
+            { index: a, ...s ? { id: s } : {}, output: { content: i } }
+          ]
+        }
+      ];
+    }
+    default:
+      return e.set(o, { kind: "other", thinking: "" }), [];
+  }
+}
+function kt(t, e) {
+  const n = I(t.index) ?? 0, o = t.delta;
+  if (!k(o)) return [];
+  switch (f(o.type)) {
+    case "text_delta": {
+      const r = f(o.text);
+      return r ? [{ text: r }] : [];
+    }
+    case "thinking_delta": {
+      const r = f(o.thinking) ?? "", s = e.get(n);
+      return s && (s.thinking += r), [{ reasoning: r, reasoningIndex: n }];
+    }
+    case "signature_delta": {
+      const r = f(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: f(o.partial_json) ?? "" }] }];
+    case "citations_delta": {
+      const r = o.citation;
+      if (!k(r)) return [];
+      const s = {}, a = f(r.url);
+      a && (s.url = a);
+      const i = f(r.title);
+      i && (s.title = i);
+      const c = f(r.cited_text);
+      return c && (s.snippet = c), Object.keys(s).length > 0 ? [{ sources: [s] }] : [];
+    }
+    default:
+      return [];
+  }
+}
+function _t(t, e) {
+  const n = I(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 vt(t) {
+  const e = {}, n = t.delta;
+  if (k(n)) {
+    const r = f(n.stop_reason);
+    r && (e.finishReason = r);
+  }
+  const o = j(t.usage);
+  return o && (e.usage = o), Object.keys(e).length > 0 ? [e] : [];
+}
+function Tt(t) {
+  const e = t.error, n = k(e) ? f(e.message) : void 0, o = k(e) ? f(e.type) : void 0;
+  return [
+    {
+      error: {
+        message: n ?? "The provider sent an error frame with no message.",
+        ...o ? { code: o } : {}
+      }
+    }
+  ];
+}
+const bt = {
+  id: "anthropic.messages",
+  open() {
+    const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+    return {
+      push(n) {
+        if (!k(n)) return [];
+        switch (f(n.type)) {
+          case "message_start": {
+            const o = n.message;
+            if (!k(o)) return [];
+            const r = j(o.usage);
+            return r ? [{ usage: r }] : [];
+          }
+          case "content_block_start":
+            return xt(n, t, e);
+          case "content_block_delta":
+            return kt(n, t);
+          case "content_block_stop":
+            return _t(n, t);
+          case "message_delta":
+            return vt(n);
+          case "error":
+            return Tt(n);
+          default:
+            return [];
+        }
+      }
+    };
+  }
+};
+class E extends Error {
+  constructor(n, o, r, s) {
+    super(It(n, o, r, s));
+    w(this, "status");
+    w(this, "statusText");
+    /** The response body parsed as JSON, or undefined when it was not JSON (an
+     *  HTML error page from a proxy, most often). */
+    w(this, "body");
+    /** The raw response body, always. */
+    w(this, "bodyText");
+    Object.setPrototypeOf(this, E.prototype), this.name = "WireError", this.status = n, this.statusText = o, this.bodyText = r, this.body = s;
+  }
+}
+function wt(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 It(t, e, n, o) {
+  const r = `Model request failed: HTTP ${t}${e ? ` ${e}` : ""}`, s = wt(o);
+  if (s) return `${r}: ${s}`;
+  const a = n.trim().slice(0, 200);
+  return a ? `${r}: ${a}` : r;
+}
+function Ot(t) {
+  return typeof t == "object" && t !== null && "ok" in t && "status" in t && "body" in t;
+}
+async function St(t) {
+  const e = await t.text().catch(() => "");
+  let n;
+  try {
+    n = e ? JSON.parse(e) : void 0;
+  } catch {
+    n = void 0;
+  }
+  return new E(t.status, t.statusText, e, n);
+}
+async function At(t) {
+  if (!Ot(t)) return t;
+  if (!t.ok) throw await St(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 M(t, e, n) {
+  const o = await At(t), r = n.format.open();
+  async function* s() {
+    for await (const a of L(o))
+      for (const i of r.push(a)) yield i;
+  }
+  return dt(s(), e, n);
+}
+function Jt(t, e, n = {}) {
+  return M(t, e, { ...n, format: mt });
+}
+function Ft(t, e, n = {}) {
+  return M(t, e, { ...n, format: bt });
+}
+function Dt(t, e, n) {
+  t.upsertTool(e, { state: "output-available", output: n });
+}
+function Wt(t, e, n) {
+  t.upsertTool(e, { state: "output-error", errorText: n });
+}
+function qt(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
+  };
+}
+class R extends Error {
+  constructor(n, o, r) {
+    super(n);
+    w(this, "messageId");
+    w(this, "partIndex");
+    Object.setPrototypeOf(this, R.prototype), this.name = "WireEncodeError", this.messageId = o, this.partIndex = r;
+  }
+}
+const N = (t) => t.type === "text", Rt = (t) => t.filter(N).map((e) => e.text).join(""), P = (t) => typeof t.toolCallId == "string" && t.toolCallId !== "" && (t.output !== void 0 || t.errorText !== void 0);
+function Ct(t) {
+  return t.rawInput !== void 0 && t.rawInput !== "" ? t.rawInput : t.input !== void 0 ? JSON.stringify(t.input) : "{}";
+}
+const Et = (t) => ({
+  id: t.toolCallId,
+  type: "function",
+  function: { name: t.type, arguments: Ct(t) }
+}), $t = (t) => ({
+  role: "tool",
+  tool_call_id: t.toolCallId,
+  name: t.type,
+  content: t.errorText ?? JSON.stringify(t.output)
+}), jt = (t) => typeof t == "object" && t !== null && !Array.isArray(t);
+function Mt(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(jt), o = n.filter((a) => a.index === t.index), r = o.length > 0 ? o : n;
+  return r[r.length - 1];
+}
+function Nt(t) {
+  const e = Mt(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 Lt(t, e = {}) {
+  const n = e.reasoning === "include", o = [];
+  for (const r of t) {
+    if (r.role === "user") {
+      const u = Rt(r.parts);
+      u !== "" && o.push({ role: "user", content: u });
+      continue;
+    }
+    let s = "", a = [], i = [];
+    const c = () => {
+      if (!(s === "" && a.length === 0)) {
+        o.push({
+          role: "assistant",
+          content: s === "" ? null : s,
+          ...i.length > 0 ? { reasoning_details: i } : {},
+          ...a.length > 0 ? { tool_calls: a.map(Et) } : {}
+        });
+        for (const u of a) o.push($t(u));
+        s = "", a = [], i = [];
+      }
+    };
+    for (const u of r.parts) {
+      if (u.type === "text") {
+        a.length > 0 && c(), s += u.text;
+        continue;
+      }
+      if (u.type === "reasoning") {
+        if (!n) continue;
+        a.length > 0 && c();
+        const l = Nt(u);
+        l && i.push(l);
+        continue;
+      }
+      u.type === "tool" && P(u.tool) && a.push(u.tool);
+    }
+    c();
+  }
+  return o;
+}
+function Kt(t) {
+  const e = [], n = (o) => {
+    const r = e[e.length - 1];
+    (r == null ? void 0 : r.role) === "user" ? r.content = [...r.content, ...o] : e.push({ role: "user", content: o });
+  };
+  for (const o of t) {
+    if (o.role === "user") {
+      const i = o.parts.filter(N).filter((c) => c.text !== "").map((c) => ({ type: "text", text: c.text }));
+      i.length > 0 && n(i);
+      continue;
+    }
+    let r = [], s = [];
+    const a = () => {
+      r.length > 0 && e.push({ role: "assistant", content: r }), s.length > 0 && n(s), r = [], s = [];
+    };
+    o.parts.forEach((i, c) => {
+      switch (i.type) {
+        case "reasoning": {
+          if (!i.raw)
+            throw new R(
+              `Cannot encode reasoning part ${c} of message "${o.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.`,
+              o.id,
+              c
+            );
+          if (!i.raw.source.startsWith("anthropic."))
+            throw new R(
+              `Cannot encode reasoning part ${c} of message "${o.id}": its \`raw\` came from "${i.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.`,
+              o.id,
+              c
+            );
+          s.length > 0 && a(), r.push(i.raw.payload);
+          break;
+        }
+        case "text": {
+          if (i.text === "") break;
+          s.length > 0 && a(), r.push({ type: "text", text: i.text });
+          break;
+        }
+        case "tool": {
+          const u = i.tool;
+          if (!P(u)) break;
+          r.push({
+            type: "tool_use",
+            id: u.toolCallId,
+            name: u.type,
+            input: u.input ?? {}
+          }), s.push(
+            u.errorText !== void 0 ? {
+              type: "tool_result",
+              tool_use_id: u.toolCallId,
+              is_error: !0,
+              content: u.errorText
+            } : {
+              type: "tool_result",
+              tool_use_id: u.toolCallId,
+              content: JSON.stringify(u.output)
+            }
+          );
+          break;
+        }
+      }
+    }), a();
+  }
+  return e;
+}
+export {
+  R as WireEncodeError,
+  E as WireError,
+  bt as anthropicMessagesFormat,
+  Wt as applyToolFailure,
+  Dt as applyToolOutput,
+  qt as bufferText,
+  dt as consumeModelStream,
+  it as createToolCallAccumulator,
+  tt as normalizeStopReason,
+  mt as openaiChatFormat,
+  Ft as readAnthropicStream,
+  M as readModelStream,
+  Jt as readOpenAIStream,
+  D as readableToAsyncIterable,
+  q as sseDataFrames,
+  L as sseJson,
+  Kt as toAnthropicMessages,
+  Lt as toOpenAIMessages
+};