@reinsjs/lowering-fetch 0.2.0

package/dist/index.js

@@ -0,0 +1,2678 @@
+// src/usage.ts
+function costOf(usage, cost) {
+  if (!cost) return void 0;
+  const perToken = (n, price) => (n ?? 0) * price / 1e6;
+  return perToken(usage.input, cost.input) + perToken(usage.output, cost.output) + perToken(usage.cacheRead, cost.cacheRead) + perToken(usage.cacheWrite, cost.cacheWrite);
+}
+
+// src/anthropic/from-stream.ts
+var REDACTED_THINKING_TEXT = "[Reasoning redacted]";
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function parseInput(json, fallback) {
+  if (json.trim() === "") return typeof fallback === "object" && fallback !== null ? fallback : {};
+  try {
+    return JSON.parse(json);
+  } catch {
+    return json;
+  }
+}
+var AnthropicAssembly = class {
+  blocks = /* @__PURE__ */ new Map();
+  start;
+  delta;
+  responseModel;
+  stopReason;
+  stopDetails;
+  error;
+  sawStop = false;
+  drafts(origin) {
+    const out = [];
+    for (const [, b] of [...this.blocks.entries()].sort((x, y) => x[0] - y[0])) {
+      const replay = { ...origin };
+      switch (b.kind) {
+        case "thinking":
+          if (b.thinking.length === 0 && b.signature.length === 0) break;
+          if (b.signature.length > 0) replay.thinkingSignature = b.signature;
+          out.push({ type: "core.model_thinking", actor: "model", payload: { text: b.thinking }, replay });
+          break;
+        case "redacted_thinking":
+          replay.thinkingSignature = b.data;
+          replay.redacted = true;
+          out.push({
+            type: "core.model_thinking",
+            actor: "model",
+            payload: { text: REDACTED_THINKING_TEXT },
+            replay
+          });
+          break;
+        case "text":
+          if (b.text.length > 0)
+            out.push({ type: "core.model_text", actor: "model", payload: { text: b.text }, replay });
+          break;
+        case "tool_use":
+          out.push({
+            type: "core.tool_call",
+            actor: "model",
+            payload: { toolCallId: b.id, name: b.name, args: parseInput(b.json, b.input) },
+            replay
+          });
+          break;
+        case "other":
+          break;
+      }
+    }
+    return out;
+  }
+  hasToolUse() {
+    for (const b of this.blocks.values()) if (b.kind === "tool_use") return true;
+    return false;
+  }
+};
+function usageOf(start, delta) {
+  const pick = (k) => num(delta?.[k]) ?? num(start?.[k]);
+  const usage = { input: pick("input_tokens") ?? 0, output: pick("output_tokens") ?? 0 };
+  const read = pick("cache_read_input_tokens");
+  const write = pick("cache_creation_input_tokens");
+  if (read) usage.cacheRead = read;
+  if (write) usage.cacheWrite = write;
+  return usage;
+}
+function apply(ev, a, ctx) {
+  switch (ev.type) {
+    case "message_start": {
+      const model = str(ev.message?.model);
+      if (model) a.responseModel = model;
+      if (ev.message?.usage) a.start = ev.message.usage;
+      break;
+    }
+    case "content_block_start": {
+      const index = num(ev.index);
+      const cb = ev.content_block;
+      if (index === void 0 || !cb) break;
+      const type = str(cb.type) ?? "unknown";
+      switch (type) {
+        case "text":
+          a.blocks.set(index, { kind: "text", text: str(cb.text) ?? "" });
+          break;
+        case "thinking":
+          a.blocks.set(index, {
+            kind: "thinking",
+            thinking: str(cb.thinking) ?? "",
+            signature: str(cb.signature) ?? ""
+          });
+          break;
+        case "redacted_thinking":
+          a.blocks.set(index, { kind: "redacted_thinking", data: str(cb.data) ?? "" });
+          break;
+        case "tool_use":
+          a.blocks.set(index, {
+            kind: "tool_use",
+            id: str(cb.id) ?? "",
+            name: str(cb.name) ?? "",
+            input: cb.input,
+            json: ""
+          });
+          break;
+        default:
+          a.blocks.set(index, { kind: "other", type });
+      }
+      break;
+    }
+    case "content_block_delta": {
+      const index = num(ev.index);
+      const d = ev.delta;
+      if (index === void 0 || !d) break;
+      const b = a.blocks.get(index);
+      if (!b) break;
+      switch (d.type) {
+        case "text_delta": {
+          const t = str(d.text);
+          if (b.kind === "text" && t) {
+            b.text += t;
+            ctx.onDelta?.({ kind: "text", index, delta: t });
+          }
+          break;
+        }
+        case "thinking_delta": {
+          const t = str(d.thinking);
+          if (b.kind === "thinking" && t) {
+            b.thinking += t;
+            ctx.onDelta?.({ kind: "thinking", index, delta: t });
+          }
+          break;
+        }
+        case "signature_delta": {
+          const s = str(d.signature);
+          if (b.kind === "thinking" && s) b.signature += s;
+          break;
+        }
+        case "input_json_delta": {
+          const j = str(d.partial_json);
+          if (b.kind === "tool_use" && j) {
+            b.json += j;
+            ctx.onDelta?.({ kind: "tool_args", index, delta: j });
+          }
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+    }
+    case "message_delta": {
+      const reason = str(ev.delta?.stop_reason);
+      if (reason) a.stopReason = reason;
+      if (ev.delta?.stop_details && typeof ev.delta.stop_details === "object")
+        a.stopDetails = ev.delta.stop_details;
+      if (ev.usage) a.delta = { ...a.delta, ...ev.usage };
+      break;
+    }
+    case "message_stop":
+      a.sawStop = true;
+      break;
+    case "error":
+      a.error = { type: str(ev.error?.type) ?? "error", message: str(ev.error?.message) ?? "" };
+      break;
+    default:
+      break;
+  }
+}
+function outcomeOf(a, cost) {
+  const usage = usageOf(a.start, a.delta);
+  const out = { stopReason: "stop", usage };
+  const c = costOf(usage, cost);
+  if (c !== void 0) out.costUsd = c;
+  if (a.responseModel) out.responseModel = a.responseModel;
+  if (a.error) {
+    out.stopReason = "error";
+    out.errorMessage = `${a.error.type}: ${a.error.message}`;
+    return out;
+  }
+  if (a.hasToolUse()) {
+    out.stopReason = "toolUse";
+    return out;
+  }
+  switch (a.stopReason) {
+    case "end_turn":
+    case "stop_sequence":
+    case "pause_turn":
+    case "tool_use":
+      break;
+    case "max_tokens":
+    case "model_context_window_exceeded":
+      out.stopReason = "length";
+      break;
+    case "refusal": {
+      out.stopReason = "error";
+      const category = str(a.stopDetails?.category);
+      const explanation = str(a.stopDetails?.explanation);
+      out.errorMessage = `stop_reason=refusal${category ? ` (${category})` : ""}: the provider's classifier refused to answer${explanation ? `: ${explanation}` : ""}`;
+      break;
+    }
+    case void 0:
+      if (!a.sawStop) {
+        out.stopReason = "error";
+        out.errorMessage = "stream ended before message_stop";
+      }
+      break;
+    default:
+      break;
+  }
+  return out;
+}
+async function* consumeAnthropicStream(input, ctx = {}) {
+  const a = new AnthropicAssembly();
+  try {
+    for await (const msg of input.messages) {
+      let ev;
+      try {
+        ev = JSON.parse(msg.data);
+      } catch {
+        continue;
+      }
+      apply(ev, a, ctx);
+      if (a.error) break;
+    }
+  } catch (err) {
+    yield* a.drafts(input.origin);
+    const base = outcomeOf(a, input.cost);
+    if (input.signal?.aborted) return { ...base, stopReason: "aborted", errorMessage: "aborted by host" };
+    if (input.timedOut?.())
+      return {
+        ...base,
+        stopReason: "error",
+        errorMessage: `request timed out after ${input.timeoutMs ?? "?"}ms (stream ended before message_stop)`
+      };
+    return { ...base, stopReason: "error", errorMessage: errorText(err) };
+  }
+  yield* a.drafts(input.origin);
+  return outcomeOf(a, input.cost);
+}
+function errorText(err) {
+  if (err instanceof Error) {
+    const cause = err.cause;
+    const code = typeof cause?.code === "string" ? ` (${cause.code})` : "";
+    return `${err.message}${code}`;
+  }
+  return String(err);
+}
+
+// src/chat/loss-matrix.ts
+var exact = (landing, note, when) => {
+  const spec = { kind: "exact", landing };
+  if (note) spec.note = note;
+  if (when) spec.when = when;
+  return spec;
+};
+var lossy = (landing, note, when) => when ? { kind: "lossy", landing, note, when } : { kind: "lossy", landing, note };
+var dropped = (landing, note, when) => when ? { kind: "dropped", landing, note, when } : { kind: "dropped", landing, note };
+var NOT_SENT = {
+  "core.approval_request": [
+    dropped("none", "the approval outcome reaches the model through tool_result(isError)")
+  ],
+  "core.approval_decision": [dropped("none", "same as above")],
+  "core.run_paused": [dropped("none", "a run record; the perception module distills it into a system_note")],
+  "core.run_resumed": [dropped("none", "same as above")],
+  "core.budget_usage": [dropped("none", "same as above")],
+  "core.memory_op": [
+    dropped(
+      "none",
+      "an audit trail of memory reads and writes; the model already learned of them from the tool result"
+    )
+  ],
+  "core.handoff": [
+    dropped(
+      "none",
+      "this session ends at the handoff; the new session's first user message carries the triggerMessage"
+    )
+  ],
+  "core.tools_bound": [
+    dropped(
+      "none",
+      "a snapshot of the tool table; the loop announces changes to it in a separate system_note"
+    )
+  ],
+  "core.error": [
+    dropped(
+      "none",
+      "provider errors are handled by the loop; tool errors already live in tool_result.isError"
+    )
+  ],
+  "ext.*": [
+    dropped(
+      "none",
+      "host extension events have no general landing; translate the ones the model must see into core events in the projection layer"
+    )
+  ]
+};
+var CHAT_LOSS_MATRIX = {
+  "core.user_message": [
+    exact("user"),
+    lossy(
+      "user",
+      "moved after that batch of tool results (the order changes), untrusted content escaped, or images replaced with placeholder text because the model takes none",
+      "the user speaks up before all tool results are in / the content holds a </untrusted / it carries images the model does not take"
+    )
+  ],
+  "core.model_text": [
+    exact("assistant-content"),
+    lossy(
+      "merged-text",
+      "multiple text segments of one turn are merged into a single string (assistant.content can only be a string)",
+      "the turn holds more than one text segment"
+    )
+  ],
+  "core.model_thinking": [
+    exact(
+      "reasoning_content",
+      "the DeepSeek dialect: the thinking text is filled back in verbatim",
+      "the model has chat.reasoningContent on and the source is the same family"
+    ),
+    dropped(
+      "none",
+      "Chat Completions has no landing for replaying thinking (no signature, no encrypted item), or the source is another family"
+    )
+  ],
+  "core.tool_call": [exact("tool_calls", "arguments is a JSON string")],
+  "core.tool_result": [
+    exact(
+      "tool",
+      "a role:tool message right after the assistant that carries the tool_calls; tool reference parts are expanded into text (Chat has no deferred-loading landing)"
+    ),
+    lossy(
+      "tool",
+      "isError is expressed with a [tool error] prefix (a tool message has no error flag), or untrusted content is escaped"
+    ),
+    lossy(
+      "tool-text-only",
+      "a tool message takes text only, so images are replaced with placeholder text",
+      "the result carries images"
+    )
+  ],
+  "core.system_note": [
+    exact(
+      "system",
+      "a mid-conversation system message",
+      "the upstream accepts mid-conversation system (the default)"
+    ),
+    lossy(
+      "system",
+      "a mid-conversation system message, with the early close inside untrusted content escaped",
+      "a note the host marked untrusted holds a </untrusted"
+    ),
+    lossy(
+      "user-role",
+      "wrapped in a <system_note> tag and sent with the user role",
+      "the model declares midConversationSystem: false"
+    )
+  ],
+  "core.compaction": [
+    lossy(
+      "user-text",
+      "the summary is rendered as user-role text, so the model cannot tell it apart from the user's own words"
+    )
+  ],
+  ...NOT_SENT
+};
+
+// src/anthropic/loss-matrix.ts
+var exact2 = (landing, note, when) => {
+  const spec = { kind: "exact", landing };
+  if (note) spec.note = note;
+  if (when) spec.when = when;
+  return spec;
+};
+var lossy2 = (landing, note, when) => when ? { kind: "lossy", landing, note, when } : { kind: "lossy", landing, note };
+var dropped2 = (landing, note, when) => when ? { kind: "dropped", landing, note, when } : { kind: "dropped", landing, note };
+var ANTHROPIC_LOSS_MATRIX = {
+  "core.user_message": [
+    exact2("user"),
+    lossy2(
+      "user",
+      "moved after that batch of tool results (the order changes), untrusted content escaped, or images replaced with placeholder text because the model takes none",
+      "the user speaks up before all tool results are in / the content holds a </untrusted / it carries images the model does not take"
+    ),
+    dropped2(
+      "none",
+      "the content is empty and Anthropic rejects empty text blocks",
+      "the user message has no non-empty content"
+    )
+  ],
+  "core.model_text": [
+    exact2(
+      "assistant-text",
+      "a text block on the assistant; each text segment of a turn becomes its own block"
+    ),
+    dropped2(
+      "none",
+      "empty text is not sent (the provider rejects empty text blocks)",
+      "the text is an empty string"
+    )
+  ],
+  "core.model_thinking": [
+    exact2(
+      "thinking-block",
+      "replayed verbatim with its signature",
+      "the replay has a thinkingSignature and comes from the same source (provider + api + model)"
+    ),
+    exact2(
+      "redacted-thinking",
+      "redacted_thinking is replayed verbatim through its data",
+      "replay.redacted is true"
+    ),
+    dropped2(
+      "none",
+      "thinking with no signature (a broken stream), from another family, or from another model of the same family (a signature is only valid for the model that produced it) is rejected by the provider, so it is not replayed, and not downgraded to text either"
+    )
+  ],
+  "core.tool_call": [
+    exact2("tool_use"),
+    lossy2("wrapped-args", "non-object arguments are wrapped as { value }", "tool_call.args is not an object")
+  ],
+  "core.tool_result": [
+    exact2(
+      "tool_result",
+      "in the user message right after the assistant that holds the tool_use; is_error is passed through; tool reference parts are expanded into text when the native capability is missing or the result is not trusted as system"
+    ),
+    lossy2(
+      "tool_result",
+      "untrusted content is escaped, or images are replaced with placeholder text because the model takes none, or the referenced tool is absent from this request's tool table and its definition is expanded into text"
+    ),
+    exact2(
+      "tool-reference",
+      "the result holds nothing but tool reference parts: a tool_reference block goes into the tool_result and the provider expands it in place into the full definition (the tool table stays byte-identical)",
+      "the model supports defer_loading, the result is trusted as system, and every referenced tool is in this request's tool table"
+    ),
+    lossy2(
+      "tool-reference",
+      "the reference block goes into the tool_result and the result's text segments move to a text block right after it in the same user message (a reference inside a tool_result cannot be mixed with text)",
+      "the result holds both reference parts and text segments (explanatory text, untrusted markers)"
+    )
+  ],
+  "core.system_note": [
+    exact2(
+      "system",
+      "a mid-conversation system message carrying the text; it is placed before the next assistant message, or at the very end",
+      "the model family supports mid-conversation system (Fable 5.x / Mythos 5.x / Opus 5 / Opus 4.8, or the host says so)"
+    ),
+    lossy2(
+      "system",
+      "a mid-conversation system message, with the early close inside untrusted content escaped",
+      "a note the host marked untrusted holds a </untrusted"
+    ),
+    lossy2(
+      "user-role",
+      "wrapped in a <system_note> tag and sent with the user role",
+      "the model family does not support mid-conversation system, or the placement rules forbid it (the previous message is an assistant, or the note would be first)"
+    )
+  ],
+  "core.compaction": [
+    lossy2(
+      "user-text",
+      "the summary is rendered as user-role text, so the model cannot tell it apart from the user's own words"
+    )
+  ],
+  ...NOT_SENT
+};
+
+// src/anthropic/to-request.ts
+import {
+  renderToolReference
+} from "@reinsjs/core";
+
+// src/ir.ts
+import {
+  markUntrusted,
+  markUntrustedText,
+  needsUntrustedMark,
+  untrustedSourceOf
+} from "@reinsjs/core";
+var DEFERRED_NOTE = "moved after that batch of tool results (tool results must immediately follow their call)";
+var ESCAPED_NOTE = "an early-closing </untrusted inside untrusted content was escaped";
+var NOT_SENT_NOTE = "operational event, not sent (the default projection already filters it)";
+function originOf(replay, fallback) {
+  const r = replay ?? {};
+  return {
+    provider: typeof r.provider === "string" ? r.provider : fallback.provider,
+    api: typeof r.api === "string" ? r.api : fallback.api,
+    model: typeof r.model === "string" ? r.model : fallback.model
+  };
+}
+function sameOrigin(a, b) {
+  return a.provider === b.provider && a.api === b.api && a.model === b.model;
+}
+function foreignOrigin(a, target) {
+  return a.provider !== target.provider || a.api !== target.api;
+}
+function eventsToIr(input) {
+  const { target } = input;
+  const trustMarkers = input.trustMarkers !== false;
+  const items = [];
+  let group = null;
+  const awaiting = /* @__PURE__ */ new Set();
+  const deferred = [];
+  const content = (e, parts) => {
+    if (!trustMarkers || !needsUntrustedMark(e)) return { parts: [...parts], escaped: false };
+    return markUntrusted(parts, untrustedSourceOf(e));
+  };
+  const text = (e, s) => {
+    if (!trustMarkers || !needsUntrustedMark(e)) return { text: s, escaped: false };
+    return markUntrustedText(s, untrustedSourceOf(e));
+  };
+  const release = () => {
+    for (const d of deferred) items.push(d);
+    deferred.length = 0;
+  };
+  const place = (item) => {
+    if (awaiting.size > 0) {
+      deferred.push({ ...item, deferred: true });
+      return;
+    }
+    items.push(item);
+  };
+  const flush = () => {
+    if (!group) return;
+    items.push({ kind: "assistant", origin: group.origin, blocks: group.blocks, at: group.at });
+    for (const b of group.blocks) if (b.type === "tool_call") awaiting.add(b.id);
+    group = null;
+  };
+  const settle = () => {
+    awaiting.clear();
+    release();
+  };
+  const assistant = (e, origin) => {
+    if (group && !sameOrigin(group.origin, origin)) flush();
+    if (!group) {
+      settle();
+      group = { origin, blocks: [], at: e.at };
+    }
+    return group;
+  };
+  for (const raw of input.events) {
+    const e = raw;
+    switch (e.type) {
+      case "core.user_message": {
+        flush();
+        const c = content(e, e.payload.content);
+        place({ kind: "user", event: e, parts: c.parts, escaped: c.escaped, deferred: false });
+        break;
+      }
+      case "core.model_thinking": {
+        assistant(e, originOf(e.replay, target)).blocks.push({
+          type: "thinking",
+          event: e,
+          text: e.payload.text,
+          replay: e.replay ?? {}
+        });
+        break;
+      }
+      case "core.model_text": {
+        assistant(e, originOf(e.replay, target)).blocks.push({
+          type: "text",
+          event: e,
+          text: e.payload.text,
+          replay: e.replay ?? {}
+        });
+        break;
+      }
+      case "core.tool_call": {
+        assistant(e, originOf(e.replay, target)).blocks.push({
+          type: "tool_call",
+          event: e,
+          id: e.payload.toolCallId,
+          name: e.payload.name,
+          args: e.payload.args,
+          replay: e.replay ?? {}
+        });
+        break;
+      }
+      case "core.tool_result": {
+        flush();
+        const c = content(e, e.payload.content);
+        items.push({
+          kind: "tool_result",
+          event: e,
+          toolCallId: e.payload.toolCallId,
+          name: e.payload.name,
+          parts: c.parts,
+          isError: e.payload.isError,
+          escaped: c.escaped
+        });
+        awaiting.delete(e.payload.toolCallId);
+        if (awaiting.size === 0) release();
+        break;
+      }
+      case "core.system_note": {
+        flush();
+        const t = text(e, e.payload.text);
+        place({
+          kind: "system_note",
+          event: e,
+          noteKind: e.payload.kind,
+          text: t.text,
+          escaped: t.escaped,
+          deferred: false
+        });
+        break;
+      }
+      case "core.compaction": {
+        flush();
+        const t = text(e, e.payload.summary);
+        place({ kind: "compaction", event: e, text: t.text, escaped: t.escaped, deferred: false });
+        break;
+      }
+      case "core.approval_request":
+      case "core.approval_decision":
+      case "core.run_paused":
+      case "core.run_resumed":
+      case "core.budget_usage":
+      case "core.memory_op":
+      case "core.handoff":
+      case "core.tools_bound":
+      case "core.error":
+        items.push({ kind: "dropped", event: e, note: NOT_SENT_NOTE });
+        break;
+      default:
+        items.push({ kind: "dropped", event: raw, note: `no general landing for ${raw.type}` });
+    }
+  }
+  flush();
+  settle();
+  return items;
+}
+function orderLandings(events, landings) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [i, e] of events.entries()) index.set(e.id, i);
+  return [...landings].sort((a, b) => (index.get(a.eventId) ?? 0) - (index.get(b.eventId) ?? 0));
+}
+
+// src/notes.ts
+function framedSystemNote(kind, text) {
+  return `<system_note kind="${kind}">
+${text}
+</system_note>`;
+}
+function framedSummary(summary) {
+  return `[Summary of earlier conversation]
+${summary}`;
+}
+
+// src/anthropic/to-request.ts
+var MAX_ANTHROPIC_BREAKPOINTS = 4;
+var IMAGE_OMITTED = "[image omitted: this model does not accept images]";
+var EMPTY_NOTE = "the content is empty and Anthropic rejects empty text blocks, so the whole message is not sent";
+var MOVED_NOTE = "moved to just after the next user message (a system message must follow a user message, and be followed by an assistant message or the end)";
+var REF_TEXT_ASIDE_NOTE = "the result's text segments move to a text block after this batch of tool_result in the same user message (a reference inside a tool_result cannot be mixed with text, and tool_result must come first in a user message)";
+var REF_UNTRUSTED_NOTE = "a tool reference in an untrusted result does not take the native landing (untrusted content must not light up tools for the model), so it is expanded into text";
+var REF_UNBOUND_NOTE = "the referenced tool is absent from this request's tool table (the provider validates references across the whole history and answers 400 if one is missing), so the definition is expanded into text";
+function land(out, e, kind, landing, ...notes) {
+  const note = notes.filter((n) => Boolean(n)).join("; ");
+  out.push(
+    note ? { eventId: e.id, type: e.type, kind, landing, note } : { eventId: e.id, type: e.type, kind, landing }
+  );
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function blocksOf(parts, images) {
+  let imagesDropped = false;
+  const blocks = [];
+  for (const p of parts) {
+    if (p.type === "text") {
+      if (p.text.length > 0) blocks.push({ type: "text", text: p.text });
+    } else if (p.type === "tool_reference") {
+      blocks.push({ type: "text", text: renderToolReference(p) });
+    } else if (images) {
+      blocks.push({ type: "image", source: { type: "base64", media_type: p.mime, data: p.data } });
+    } else {
+      imagesDropped = true;
+      blocks.push({ type: "text", text: IMAGE_OMITTED });
+    }
+  }
+  return { blocks, imagesDropped };
+}
+function encodeAnthropicRequest(input) {
+  const { model, capabilities } = input;
+  const target = { provider: model.provider, api: model.api, model: model.id };
+  const dialect = model.anthropic ?? {};
+  const boundNames = new Set((input.tools ?? []).map((t) => t.name));
+  const messages = [];
+  const landings = [];
+  let userRun = null;
+  let asides = [];
+  const pendingNotes = [];
+  const openUser = () => {
+    if (!userRun) userRun = [];
+    for (const n of pendingNotes) n.moved = true;
+    return userRun;
+  };
+  const closeUser = () => {
+    if (userRun && asides.length > 0) {
+      const lastResult = userRun.map((b) => b.type).lastIndexOf("tool_result");
+      userRun.splice(lastResult + 1, 0, ...asides);
+      asides = [];
+    }
+    if (userRun && userRun.length > 0) messages.push({ role: "user", content: userRun });
+    userRun = null;
+  };
+  const flushNotes = () => {
+    closeUser();
+    if (pendingNotes.length === 0) return;
+    const last = messages[messages.length - 1];
+    if (last && last.role !== "assistant") {
+      for (const { item, moved } of pendingNotes) {
+        messages.push({ role: "system", content: [{ type: "text", text: item.text }] });
+        land(
+          landings,
+          item.event,
+          item.escaped ? "lossy" : "exact",
+          "system",
+          item.escaped ? ESCAPED_NOTE : void 0,
+          item.deferred ? DEFERRED_NOTE : void 0,
+          moved ? MOVED_NOTE : void 0
+        );
+      }
+    } else {
+      const why = last ? "the previous message is an assistant, and a system message must follow a user message" : "a system message cannot come first";
+      messages.push({
+        role: "user",
+        content: pendingNotes.map(({ item }) => ({
+          type: "text",
+          text: framedSystemNote(item.noteKind, item.text)
+        }))
+      });
+      for (const { item } of pendingNotes) {
+        land(
+          landings,
+          item.event,
+          "lossy",
+          "user-role",
+          `${why}, so it is wrapped in a <system_note> tag and sent with the user role`,
+          item.escaped ? ESCAPED_NOTE : void 0,
+          item.deferred ? DEFERRED_NOTE : void 0
+        );
+      }
+    }
+    pendingNotes.length = 0;
+  };
+  for (const item of input.ir) {
+    switch (item.kind) {
+      case "user": {
+        const c = blocksOf(item.parts, capabilities.images);
+        if (c.blocks.length === 0) {
+          land(landings, item.event, "dropped", "none", EMPTY_NOTE);
+          break;
+        }
+        openUser().push(...c.blocks);
+        const lossy4 = item.deferred || item.escaped || c.imagesDropped;
+        land(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          "user",
+          item.deferred ? `the user message sits between a tool call and its results; ${DEFERRED_NOTE}` : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0,
+          c.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0
+        );
+        break;
+      }
+      case "tool_result": {
+        const refs = item.parts.filter(
+          (p) => p.type === "tool_reference"
+        );
+        const block = { type: "tool_result", tool_use_id: item.toolCallId };
+        if (item.isError) block.is_error = true;
+        const trusted = item.event.trust === "system";
+        if (refs.length > 0 && capabilities.deferredTools && trusted && refs.every((r) => boundNames.has(r.name))) {
+          block.content = refs.map((r) => ({ type: "tool_reference", tool_name: r.name }));
+          const rest = blocksOf(
+            item.parts.filter((p) => p.type !== "tool_reference"),
+            capabilities.images
+          );
+          openUser().push(block);
+          asides.push(...rest.blocks);
+          const aside = rest.blocks.length > 0;
+          land(
+            landings,
+            item.event,
+            aside || item.escaped || rest.imagesDropped ? "lossy" : "exact",
+            "tool-reference",
+            aside ? REF_TEXT_ASIDE_NOTE : void 0,
+            rest.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0,
+            item.escaped ? ESCAPED_NOTE : void 0
+          );
+          break;
+        }
+        const c = blocksOf(item.parts, capabilities.images);
+        if (c.blocks.length > 0) block.content = c.blocks;
+        openUser().push(block);
+        const unbound = refs.length > 0 && capabilities.deferredTools && trusted;
+        const untrustedRefs = refs.length > 0 && capabilities.deferredTools && !trusted;
+        const lossy4 = item.escaped || c.imagesDropped || unbound;
+        land(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          "tool_result",
+          unbound ? REF_UNBOUND_NOTE : void 0,
+          untrustedRefs ? REF_UNTRUSTED_NOTE : void 0,
+          c.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0
+        );
+        break;
+      }
+      case "compaction": {
+        openUser().push({ type: "text", text: framedSummary(item.text) });
+        land(
+          landings,
+          item.event,
+          "lossy",
+          "user-text",
+          "the summary is rendered as user-role text",
+          item.escaped ? ESCAPED_NOTE : void 0,
+          item.deferred ? DEFERRED_NOTE : void 0
+        );
+        break;
+      }
+      case "system_note": {
+        if (capabilities.midConversationSystem) {
+          pendingNotes.push({ item, moved: false });
+        } else {
+          openUser().push({ type: "text", text: framedSystemNote(item.noteKind, item.text) });
+          land(
+            landings,
+            item.event,
+            "lossy",
+            "user-role",
+            "the model does not support mid-conversation system, so it is wrapped in a <system_note> tag and sent with the user role",
+            item.escaped ? ESCAPED_NOTE : void 0,
+            item.deferred ? DEFERRED_NOTE : void 0
+          );
+        }
+        break;
+      }
+      case "assistant": {
+        const content = assistantBlocks(item.blocks, item.origin, target, landings);
+        if (content.length === 0) break;
+        flushNotes();
+        messages.push({ role: "assistant", content });
+        break;
+      }
+      case "dropped":
+        land(landings, item.event, "dropped", "none", item.note);
+        break;
+    }
+  }
+  flushNotes();
+  const ro = input.requestOptions ?? {};
+  const { system: _system, tools: _tools, ...passthrough } = ro;
+  const body = {
+    ...passthrough,
+    model: model.id,
+    max_tokens: typeof ro.max_tokens === "number" ? ro.max_tokens : model.maxOutputTokens,
+    messages,
+    stream: true
+  };
+  if (input.systemPrompt) body.system = [{ type: "text", text: input.systemPrompt }];
+  if (input.tools && input.tools.length > 0) {
+    const tools = encodeTools(input.tools, capabilities.deferredTools);
+    if (tools.length > 0) body.tools = tools;
+  }
+  if (dialect.cacheBreakpoints !== false) placeCacheBreakpoints(body, dialect);
+  return { body, landings: orderLandings(input.events, landings) };
+}
+function assistantBlocks(blocks, origin, target, landings) {
+  const out = [];
+  const foreign = foreignOrigin(origin, target);
+  for (const b of blocks) {
+    switch (b.type) {
+      case "text":
+        if (b.text.length === 0) {
+          land(landings, b.event, "dropped", "none", EMPTY_NOTE);
+          break;
+        }
+        out.push({ type: "text", text: b.text });
+        land(landings, b.event, "exact", "assistant-text");
+        break;
+      case "thinking": {
+        const signature = typeof b.replay.thinkingSignature === "string" ? b.replay.thinkingSignature : "";
+        if (foreign) {
+          land(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            `thinking from ${origin.provider}/${origin.api} has no signature of its own, so it is not replayed`
+          );
+          break;
+        }
+        if (signature.length === 0) {
+          land(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            "thinking with no signature (a broken stream) is rejected by the provider, so it is not replayed"
+          );
+          break;
+        }
+        if (origin.model !== target.model) {
+          land(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            `the signature comes from ${origin.model}, but this request targets ${target.model}; a signature is only valid for the model that produced it, so the block is not replayed`
+          );
+          break;
+        }
+        if (b.replay.redacted === true) {
+          out.push({ type: "redacted_thinking", data: signature });
+          land(
+            landings,
+            b.event,
+            "exact",
+            "redacted-thinking",
+            "redacted_thinking is replayed verbatim through its data"
+          );
+        } else {
+          out.push({ type: "thinking", thinking: b.text, signature });
+          land(landings, b.event, "exact", "thinking-block");
+        }
+        break;
+      }
+      case "tool_call": {
+        const wrapped = !isPlainObject(b.args);
+        out.push({
+          type: "tool_use",
+          id: b.id,
+          name: b.name,
+          input: wrapped ? { value: b.args } : b.args
+        });
+        if (wrapped)
+          land(
+            landings,
+            b.event,
+            "lossy",
+            "wrapped-args",
+            "non-object arguments are wrapped as { value } (tool_use.input must be an object)"
+          );
+        else land(landings, b.event, "exact", "tool_use");
+        break;
+      }
+    }
+  }
+  return out;
+}
+function encodeTools(specs, deferredTools) {
+  const shown = deferredTools ? specs : specs.filter((t) => t.deferLoading !== true);
+  const allDeferred = deferredTools && shown.length > 0 && shown.every((t) => t.deferLoading === true);
+  return shown.map((t) => {
+    const tool = { name: t.name, description: t.description, input_schema: t.inputSchema };
+    if (deferredTools && t.deferLoading === true && !allDeferred) tool.defer_loading = true;
+    return tool;
+  });
+}
+function countBlockBreakpoints(body) {
+  const has = (b) => typeof b === "object" && b !== null && "cache_control" in b;
+  let n = 0;
+  for (const s of body.system ?? []) if (has(s)) n++;
+  for (const t of body.tools ?? []) if (has(t)) n++;
+  for (const m of body.messages) for (const b of m.content) if (has(b)) n++;
+  return n;
+}
+function placeCacheBreakpoints(body, dialect) {
+  const cc = dialect.cacheTtl === "1h" ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
+  const budget = () => MAX_ANTHROPIC_BREAKPOINTS - countBlockBreakpoints(body) - (body.cache_control ? 1 : 0);
+  const lastSystem = body.system?.[body.system.length - 1];
+  if (lastSystem && budget() > 0) lastSystem.cache_control = cc;
+  const lastTool = [...body.tools ?? []].reverse().find((t) => t.defer_loading !== true);
+  if (lastTool && budget() > 0) lastTool.cache_control = cc;
+  const last = body.messages[body.messages.length - 1];
+  if (!last) return;
+  const markLastUser = (m) => {
+    if (m?.role !== "user") return;
+    const block = m.content[m.content.length - 1];
+    if (block && budget() > 0) block.cache_control = cc;
+  };
+  if (last.role === "user") {
+    markLastUser(last);
+    return;
+  }
+  if (last.role !== "system") return;
+  switch (dialect.midSystemCacheBreakpoint ?? "automatic") {
+    case "automatic":
+      if (body.cache_control === void 0 && budget() > 0) body.cache_control = cc;
+      break;
+    case "previous-user":
+      markLastUser([...body.messages].reverse().find((m) => m.role === "user"));
+      break;
+    case "drop":
+      break;
+  }
+}
+
+// src/capabilities.ts
+var ANTHROPIC_MID_SYSTEM = /^claude-(fable-5|mythos-5|opus-5|opus-4-8)(-|$)/;
+var ANTHROPIC_TASK_BUDGET = /^claude-(opus-5|fable-5-1)(-|$)/;
+function capabilitiesOf(model) {
+  const base = {
+    api: model.api,
+    parallelTools: true,
+    images: model.images ?? false,
+    contextWindow: model.contextWindow,
+    maxOutputTokens: model.maxOutputTokens,
+    taskBudget: false,
+    // 只有 Anthropic 线有 defer_loading / tool_reference 的原生落点（L1）；其余线引用段展开成文本、deferLoading 的工具不发
+    deferredTools: false
+  };
+  switch (model.api) {
+    case "openai-chat":
+      return {
+        ...base,
+        // Chat 的 system 消息可出现在任意位置（OpenAI 官方与 DeepSeek 实测到达），宿主可对特殊上游关掉
+        midConversationSystem: model.midConversationSystem ?? true,
+        // 官方 Chat 没有 thinking 回放位；只有 DeepSeek 方言的 reasoning_content 能把思考原样回填
+        thinkingReplay: model.reasoning && model.chat?.reasoningContent === true
+      };
+    case "anthropic-messages":
+      return {
+        ...base,
+        midConversationSystem: model.midConversationSystem ?? ANTHROPIC_MID_SYSTEM.test(model.id),
+        // 带 signature 的 thinking 块可原样回放（F0 A7b 实测接受、伪造签名 400）
+        thinkingReplay: model.reasoning,
+        taskBudget: ANTHROPIC_TASK_BUDGET.test(model.id),
+        // 官方模型 Haiku 4.5 起都支持（L1 spike 实测 Haiku 4.5 / Opus 5）；第三方兼容上游由宿主声明
+        deferredTools: model.anthropic?.deferredTools ?? model.provider === "anthropic"
+      };
+    case "openai-responses":
+      return {
+        ...base,
+        // input 项里 developer / system 消息可出现在任意位置（F0 R3 实测中途 developer 到达），无归位需求
+        midConversationSystem: model.midConversationSystem ?? true,
+        // reasoning 项以 encrypted_content 原样回放（F0 R3 接受、伪造 400）；关掉 encryptedReasoning 就没有可回放的东西
+        thinkingReplay: model.reasoning && model.responses?.encryptedReasoning !== false
+      };
+    default:
+      return { ...base, midConversationSystem: model.midConversationSystem ?? false, thinkingReplay: false };
+  }
+}
+
+// src/chat/from-stream.ts
+var ChatAssembly = class {
+  reasoning = "";
+  text = "";
+  calls = /* @__PURE__ */ new Map();
+  finish;
+  usage;
+  responseModel;
+  /** onDelta 用的块序号：按首次出现顺序分配 */
+  blockIndex = /* @__PURE__ */ new Map();
+  indexOf(key) {
+    let i = this.blockIndex.get(key);
+    if (i === void 0) {
+      i = this.blockIndex.size;
+      this.blockIndex.set(key, i);
+    }
+    return i;
+  }
+  drafts(origin) {
+    const out = [];
+    const replay = { ...origin };
+    if (this.reasoning.length > 0)
+      out.push({ type: "core.model_thinking", actor: "model", payload: { text: this.reasoning }, replay });
+    if (this.text.length > 0)
+      out.push({ type: "core.model_text", actor: "model", payload: { text: this.text }, replay });
+    for (const [, c] of [...this.calls.entries()].sort((a, b) => a[0] - b[0])) {
+      out.push({
+        type: "core.tool_call",
+        actor: "model",
+        payload: { toolCallId: c.id, name: c.name, args: parseArguments(c.args) },
+        replay
+      });
+    }
+    return out;
+  }
+};
+function parseArguments(raw) {
+  if (raw.trim() === "") return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function num2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function usageOf2(u) {
+  const prompt = num2(u?.prompt_tokens) ?? 0;
+  const cached = num2(u?.prompt_tokens_details?.cached_tokens) ?? num2(u?.prompt_cache_hit_tokens) ?? 0;
+  const usage = { input: Math.max(0, prompt - cached), output: num2(u?.completion_tokens) ?? 0 };
+  if (cached > 0) usage.cacheRead = cached;
+  return usage;
+}
+function apply2(chunk, a, ctx) {
+  if (typeof chunk.model === "string" && chunk.model !== "") a.responseModel = chunk.model;
+  if (chunk.usage && typeof chunk.usage === "object") a.usage = chunk.usage;
+  const choice = chunk.choices?.[0];
+  if (!choice) return;
+  const d = choice.delta;
+  if (d) {
+    if (typeof d.reasoning_content === "string" && d.reasoning_content !== "") {
+      a.reasoning += d.reasoning_content;
+      ctx.onDelta?.({ kind: "thinking", index: a.indexOf("thinking"), delta: d.reasoning_content });
+    }
+    if (typeof d.content === "string" && d.content !== "") {
+      a.text += d.content;
+      ctx.onDelta?.({ kind: "text", index: a.indexOf("text"), delta: d.content });
+    }
+    for (const tc of d.tool_calls ?? []) {
+      const index = num2(tc.index) ?? 0;
+      let call = a.calls.get(index);
+      if (!call) {
+        call = { id: "", name: "", args: "" };
+        a.calls.set(index, call);
+      }
+      if (typeof tc.id === "string" && tc.id !== "") call.id = tc.id;
+      if (typeof tc.function?.name === "string" && tc.function.name !== "") call.name = tc.function.name;
+      if (typeof tc.function?.arguments === "string" && tc.function.arguments !== "") {
+        call.args += tc.function.arguments;
+        ctx.onDelta?.({ kind: "tool_args", index: a.indexOf(`tool:${index}`), delta: tc.function.arguments });
+      }
+    }
+  }
+  if (typeof choice.finish_reason === "string") a.finish = choice.finish_reason;
+}
+function outcomeOf2(a, cost, sawDone) {
+  const usage = usageOf2(a.usage);
+  const out = { stopReason: "stop", usage };
+  const c = costOf(usage, cost);
+  if (c !== void 0) out.costUsd = c;
+  if (a.responseModel) out.responseModel = a.responseModel;
+  if (a.calls.size > 0) out.stopReason = "toolUse";
+  else {
+    switch (a.finish) {
+      case "stop":
+      case "tool_calls":
+        break;
+      case "length":
+        out.stopReason = "length";
+        break;
+      case "content_filter":
+        out.stopReason = "error";
+        out.errorMessage = "finish_reason=content_filter: the provider's content filter cut this output short";
+        break;
+      case "insufficient_system_resource":
+        out.stopReason = "error";
+        out.errorMessage = "finish_reason=insufficient_system_resource (service temporarily unavailable)";
+        break;
+      case "aborted":
+        out.stopReason = "error";
+        out.errorMessage = "finish_reason=aborted: the server aborted this generation";
+        break;
+      case void 0:
+        if (!sawDone || a.text.length === 0) {
+          out.stopReason = "error";
+          out.errorMessage = "stream ended before finish_reason";
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return out;
+}
+async function* consumeChatStream(input, ctx = {}) {
+  const a = new ChatAssembly();
+  let sawDone = false;
+  try {
+    for await (const msg of input.messages) {
+      if (msg.data === "[DONE]") {
+        sawDone = true;
+        break;
+      }
+      let chunk;
+      try {
+        chunk = JSON.parse(msg.data);
+      } catch {
+        continue;
+      }
+      apply2(chunk, a, ctx);
+    }
+  } catch (err) {
+    yield* a.drafts(input.origin);
+    const base = outcomeOf2(a, input.cost, false);
+    if (input.signal?.aborted) return { ...base, stopReason: "aborted", errorMessage: "aborted by host" };
+    if (input.timedOut?.())
+      return {
+        ...base,
+        stopReason: "error",
+        errorMessage: `request timed out after ${input.timeoutMs ?? "?"}ms (stream ended before finish_reason)`
+      };
+    return { ...base, stopReason: "error", errorMessage: errorText2(err) };
+  }
+  yield* a.drafts(input.origin);
+  return outcomeOf2(a, input.cost, sawDone);
+}
+function errorText2(err) {
+  if (err instanceof Error) {
+    const cause = err.cause;
+    const code = typeof cause?.code === "string" ? ` (${cause.code})` : "";
+    return `${err.message}${code}`;
+  }
+  return String(err);
+}
+
+// src/chat/to-request.ts
+import {
+  renderToolReference as renderToolReference2
+} from "@reinsjs/core";
+var IMAGE_OMITTED2 = "[image omitted: this model does not accept images]";
+var TOOL_IMAGE_OMITTED = "[image omitted: tool messages carry text only]";
+var ERROR_PREFIX = "[tool error]\n";
+function land2(out, e, kind, landing, ...notes) {
+  const note = notes.filter((n) => Boolean(n)).join("; ");
+  out.push(
+    note ? { eventId: e.id, type: e.type, kind, landing, note } : { eventId: e.id, type: e.type, kind, landing }
+  );
+}
+function userContent(parts, images) {
+  let imagesDropped = false;
+  const out = parts.map((p) => {
+    if (p.type === "text") return { type: "text", text: p.text };
+    if (p.type === "tool_reference") return { type: "text", text: renderToolReference2(p) };
+    if (!images) {
+      imagesDropped = true;
+      return { type: "text", text: IMAGE_OMITTED2 };
+    }
+    return { type: "image_url", image_url: { url: `data:${p.mime};base64,${p.data}` } };
+  });
+  if (out.length === 1 && out[0]?.type === "text") return { content: out[0].text, imagesDropped };
+  return { content: out, imagesDropped };
+}
+function toolContent(parts) {
+  let imagesDropped = false;
+  const text = parts.map((p) => {
+    if (p.type === "text") return p.text;
+    if (p.type === "tool_reference") return renderToolReference2(p);
+    imagesDropped = true;
+    return TOOL_IMAGE_OMITTED;
+  }).join("\n");
+  return { text, imagesDropped };
+}
+function argumentsOf(args) {
+  return typeof args === "string" ? args : JSON.stringify(args ?? {});
+}
+function encodeChatRequest(input) {
+  const { model, capabilities } = input;
+  const target = { provider: model.provider, api: model.api, model: model.id };
+  const reasoningContent = model.chat?.reasoningContent === true;
+  const messages = [];
+  const landings = [];
+  if (input.systemPrompt) messages.push({ role: "system", content: input.systemPrompt });
+  for (const item of input.ir) {
+    switch (item.kind) {
+      case "user": {
+        const c = userContent(item.parts, capabilities.images);
+        messages.push({ role: "user", content: c.content });
+        const lossy4 = item.deferred || item.escaped || c.imagesDropped;
+        land2(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          "user",
+          item.deferred ? `the user message sits between a tool call and its results; ${DEFERRED_NOTE}` : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0,
+          c.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0
+        );
+        break;
+      }
+      case "assistant": {
+        messages.push(assistantMessage(item.blocks, item.origin, target, reasoningContent, landings));
+        break;
+      }
+      case "tool_result": {
+        const c = toolContent(item.parts);
+        messages.push({
+          role: "tool",
+          tool_call_id: item.toolCallId,
+          content: item.isError ? ERROR_PREFIX + c.text : c.text
+        });
+        const lossy4 = item.escaped || item.isError || c.imagesDropped;
+        land2(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          c.imagesDropped ? "tool-text-only" : "tool",
+          item.isError ? "a Chat tool message has no error flag, so isError is expressed with a [tool error] prefix" : void 0,
+          c.imagesDropped ? "a tool message takes text only, so images are replaced with placeholder text" : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0
+        );
+        break;
+      }
+      case "system_note": {
+        if (capabilities.midConversationSystem) {
+          messages.push({ role: "system", content: item.text });
+          land2(
+            landings,
+            item.event,
+            item.escaped ? "lossy" : "exact",
+            "system",
+            item.escaped ? ESCAPED_NOTE : void 0,
+            item.deferred ? DEFERRED_NOTE : void 0
+          );
+        } else {
+          messages.push({ role: "user", content: framedSystemNote(item.noteKind, item.text) });
+          land2(
+            landings,
+            item.event,
+            "lossy",
+            "user-role",
+            "the upstream does not accept mid-conversation system, so it is wrapped in a <system_note> tag and sent with the user role",
+            item.escaped ? ESCAPED_NOTE : void 0,
+            item.deferred ? DEFERRED_NOTE : void 0
+          );
+        }
+        break;
+      }
+      case "compaction": {
+        messages.push({ role: "user", content: framedSummary(item.text) });
+        land2(
+          landings,
+          item.event,
+          "lossy",
+          "user-text",
+          "the summary is rendered as user-role text",
+          item.escaped ? ESCAPED_NOTE : void 0,
+          item.deferred ? DEFERRED_NOTE : void 0
+        );
+        break;
+      }
+      case "dropped":
+        land2(landings, item.event, "dropped", "none", item.note);
+        break;
+    }
+  }
+  const { tools: _tools, ...passthrough } = input.requestOptions ?? {};
+  const shownTools = (input.tools ?? []).filter((t) => t.deferLoading !== true);
+  const body = {
+    ...passthrough,
+    model: model.id,
+    messages,
+    ...shownTools.length > 0 ? {
+      tools: shownTools.map(
+        (t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.inputSchema }
+        })
+      )
+    } : {},
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  return { body, landings: orderLandings(input.events, landings) };
+}
+function assistantMessage(blocks, origin, target, reasoningContent, landings) {
+  const texts = blocks.filter((b) => b.type === "text");
+  const thinkings = blocks.filter((b) => b.type === "thinking");
+  const calls = blocks.filter((b) => b.type === "tool_call");
+  const foreign = foreignOrigin(origin, target);
+  for (const t of texts) {
+    if (texts.length > 1)
+      land2(
+        landings,
+        t.event,
+        "lossy",
+        "merged-text",
+        "multiple text segments of one turn are merged into a single string"
+      );
+    else land2(landings, t.event, "exact", "assistant-content");
+  }
+  const replayable = reasoningContent && !foreign;
+  for (const t of thinkings) {
+    if (replayable) land2(landings, t.event, "exact", "reasoning_content");
+    else if (reasoningContent)
+      land2(
+        landings,
+        t.event,
+        "dropped",
+        "none",
+        `thinking from ${origin.provider}/${origin.api} is not filled back in for a model of another family`
+      );
+    else
+      land2(
+        landings,
+        t.event,
+        "dropped",
+        "none",
+        "Chat Completions has no landing for replaying thinking (no signature, no encrypted item)"
+      );
+  }
+  for (const c of calls) land2(landings, c.event, "exact", "tool_calls");
+  const msg = {
+    role: "assistant",
+    content: texts.length > 0 ? texts.map((t) => t.text).join("\n\n") : null
+  };
+  if (calls.length > 0) {
+    msg.tool_calls = calls.map((c) => ({
+      id: c.id,
+      type: "function",
+      function: { name: c.name, arguments: argumentsOf(c.args) }
+    }));
+  }
+  if (reasoningContent) msg.reasoning_content = replayable ? thinkings.map((t) => t.text).join("\n") : "";
+  return msg;
+}
+
+// src/lowering.ts
+import {
+  LoweringError as LoweringError2
+} from "@reinsjs/core";
+
+// src/http.ts
+var HttpError = class extends Error {
+  constructor(status, headers, body, url) {
+    super(`${status} ${body}`);
+    this.status = status;
+    this.headers = headers;
+    this.body = body;
+    this.url = url;
+  }
+  status;
+  headers;
+  body;
+  url;
+  name = "HttpError";
+};
+var DEFAULT_TIMEOUT_MS = 6e5;
+function requestSignals(hostSignal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const signal = hostSignal ? AbortSignal.any([hostSignal, timeout]) : timeout;
+  return { signal, timedOut: () => timeout.aborted && !hostSignal?.aborted };
+}
+async function postJson(input) {
+  const doFetch = input.fetch ?? globalThis.fetch;
+  const res = await doFetch(input.url, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "text/event-stream", ...input.headers },
+    body: JSON.stringify(input.body),
+    signal: input.signal
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, res.headers, text, input.url);
+  }
+  return res;
+}
+
+// src/models.ts
+import { LoweringError } from "@reinsjs/core";
+var SUPPORTED_APIS = /* @__PURE__ */ new Set([
+  "openai-chat",
+  "anthropic-messages",
+  "openai-responses"
+]);
+var DEEPSEEK_BASE = "https://api.deepseek.com";
+var ANTHROPIC_BASE = "https://api.anthropic.com/v1";
+var anthropicModel = (id, cost, extra = {}) => ({
+  provider: "anthropic",
+  id,
+  api: "anthropic-messages",
+  baseUrl: ANTHROPIC_BASE,
+  contextWindow: 1e6,
+  maxOutputTokens: 128e3,
+  reasoning: true,
+  images: true,
+  cost,
+  ...extra
+});
+var HAIKU_4_5 = anthropicModel(
+  "claude-haiku-4-5",
+  { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  { contextWindow: 2e5, maxOutputTokens: 64e3 }
+);
+var OPENAI_BASE = "https://api.openai.com/v1";
+var DEEPSEEK_FLASH = {
+  provider: "deepseek",
+  id: "deepseek-flash",
+  api: "openai-chat",
+  baseUrl: DEEPSEEK_BASE,
+  contextWindow: 1e6,
+  maxOutputTokens: 384e3,
+  reasoning: true,
+  images: true,
+  cost: { input: 0.3, output: 1.2, cacheRead: 6e-3, cacheWrite: 0 },
+  chat: { reasoningContent: true }
+};
+var responsesModel = (id, cost, extra) => ({
+  provider: "openai",
+  id,
+  api: "openai-responses",
+  baseUrl: OPENAI_BASE,
+  images: true,
+  cost,
+  ...extra
+});
+var GPT5 = { reasoning: true, contextWindow: 4e5, maxOutputTokens: 128e3 };
+var GPT5_LARGE = { reasoning: true, contextWindow: 272e3, maxOutputTokens: 128e3 };
+var O_SERIES = { reasoning: true, contextWindow: 2e5, maxOutputTokens: 1e5 };
+var BUILTIN_MODELS = [
+  anthropicModel("claude-fable-5-1", { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 }),
+  anthropicModel("claude-opus-5", { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }),
+  anthropicModel("claude-opus-4-8", { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }),
+  anthropicModel("claude-sonnet-5", { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }),
+  HAIKU_4_5,
+  // 带日期后缀的正式 id 与短名同一份定义
+  { ...HAIKU_4_5, id: "claude-haiku-4-5-20251001" },
+  DEEPSEEK_FLASH,
+  // 别名：模型列表里只有 deepseek-flash，请求带 deepseek-v4-flash 照样接受、响应报 deepseek-flash
+  { ...DEEPSEEK_FLASH, id: "deepseek-v4-flash" },
+  {
+    provider: "deepseek",
+    id: "deepseek-v4-pro",
+    api: "openai-chat",
+    baseUrl: DEEPSEEK_BASE,
+    contextWindow: 1e6,
+    maxOutputTokens: 384e3,
+    reasoning: true,
+    images: true,
+    cost: { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0 },
+    chat: { reasoningContent: true }
+  },
+  // ---- OpenAI Responses 线：OpenAI 官方的主协议，同 id 无协议解析时先取它；Chat 条目在后面
+  responsesModel("gpt-5.5", { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 }, GPT5_LARGE),
+  responsesModel("gpt-5.4", { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 }, GPT5_LARGE),
+  responsesModel("gpt-5.4-mini", { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 }, GPT5),
+  responsesModel("gpt-5.2", { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 }, GPT5),
+  responsesModel("gpt-5.1", { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 }, GPT5),
+  responsesModel("gpt-5", { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 }, GPT5),
+  responsesModel("gpt-5-mini", { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0 }, GPT5),
+  responsesModel("gpt-5-nano", { input: 0.05, output: 0.4, cacheRead: 5e-3, cacheWrite: 0 }, GPT5),
+  responsesModel("o3", { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 }, O_SERIES),
+  responsesModel("o4-mini", { input: 1.1, output: 4.4, cacheRead: 0.275, cacheWrite: 0 }, O_SERIES),
+  responsesModel(
+    "gpt-4.1",
+    { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
+    { reasoning: false, contextWindow: 1047576, maxOutputTokens: 32768 }
+  ),
+  responsesModel(
+    "gpt-4.1-mini",
+    { input: 0.4, output: 1.6, cacheRead: 0.1, cacheWrite: 0 },
+    { reasoning: false, contextWindow: 1047576, maxOutputTokens: 32768 }
+  ),
+  responsesModel(
+    "gpt-4o-mini",
+    { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0 },
+    { reasoning: false, contextWindow: 128e3, maxOutputTokens: 16384 }
+  ),
+  // ---- OpenAI Chat Completions 线的同款型号（openaiChat() 按协议精确取；无协议解析时上面的 Responses 条目优先）
+  {
+    provider: "openai",
+    id: "gpt-4o-mini",
+    api: "openai-chat",
+    baseUrl: OPENAI_BASE,
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    reasoning: false,
+    images: true,
+    cost: { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0 }
+  },
+  {
+    provider: "openai",
+    id: "gpt-4.1",
+    api: "openai-chat",
+    baseUrl: OPENAI_BASE,
+    contextWindow: 1047576,
+    maxOutputTokens: 32768,
+    reasoning: false,
+    images: true,
+    cost: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 }
+  },
+  {
+    provider: "openai",
+    id: "gpt-4.1-mini",
+    api: "openai-chat",
+    baseUrl: OPENAI_BASE,
+    contextWindow: 1047576,
+    maxOutputTokens: 32768,
+    reasoning: false,
+    images: true,
+    cost: { input: 0.4, output: 1.6, cacheRead: 0.1, cacheWrite: 0 }
+  },
+  {
+    provider: "openai",
+    id: "gpt-5-mini",
+    api: "openai-chat",
+    baseUrl: OPENAI_BASE,
+    contextWindow: 4e5,
+    maxOutputTokens: 128e3,
+    reasoning: true,
+    images: true,
+    cost: { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0 }
+  }
+];
+function findBuiltin(provider, id, api) {
+  return BUILTIN_MODELS.find(
+    (m) => m.provider === provider && m.id === id && (api === void 0 || m.api === api)
+  );
+}
+function resolveModel(ref, extra = []) {
+  const model = extra.find((m) => m.provider === ref.provider && m.id === ref.id) ?? findBuiltin(ref.provider, ref.id);
+  if (!model) {
+    throw new LoweringError(
+      "unsupported_model",
+      `unknown model ${ref.provider}/${ref.id}; the built-in table is a minimal set, declare the rest through the models option (or use a factory function)`,
+      { provider: ref.provider, id: ref.id }
+    );
+  }
+  if (!SUPPORTED_APIS.has(model.api)) {
+    throw new LoweringError(
+      "unsupported_api",
+      `model ${ref.provider}/${ref.id} speaks ${model.api}, but this implementation currently supports only ${[...SUPPORTED_APIS].join(" / ")}`,
+      { api: model.api }
+    );
+  }
+  return model;
+}
+function endpointOf(model) {
+  const base = model.baseUrl.replace(/\/+$/, "");
+  switch (model.api) {
+    case "openai-chat":
+      return `${base}/chat/completions`;
+    case "anthropic-messages":
+      return `${base}/messages`;
+    case "openai-responses":
+      return `${base}/responses`;
+  }
+}
+
+// src/responses/from-stream.ts
+function str2(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num3(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function parseArguments2(raw) {
+  if (raw.trim() === "") return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function reasoningText(item, fallback) {
+  if (!item) return fallback;
+  const summary = (item.summary ?? []).map((s) => str2(s.text) ?? "").filter((t) => t.length > 0);
+  if (summary.length > 0) return summary.join("\n\n");
+  const content = (item.content ?? []).map((c) => str2(c.text) ?? "").filter((t) => t.length > 0);
+  return content.length > 0 ? content.join("\n\n") : fallback;
+}
+function messageText(item, fallback) {
+  if (!item?.content) return fallback;
+  return item.content.map((c) => (c.type === "refusal" ? str2(c.refusal) : str2(c.text)) ?? "").join("");
+}
+var ResponsesAssembly = class {
+  slots = /* @__PURE__ */ new Map();
+  responseId;
+  responseModel;
+  status;
+  incompleteReason;
+  usage;
+  error;
+  sawTerminal = false;
+  slotFor(index, item) {
+    let slot = this.slots.get(index);
+    if (slot) return slot;
+    const type = str2(item.type) ?? "unknown";
+    switch (type) {
+      case "reasoning":
+        slot = { kind: "reasoning", id: str2(item.id) ?? "", summary: "", item: void 0 };
+        break;
+      case "message":
+        slot = { kind: "message", id: str2(item.id) ?? "", text: "", phase: str2(item.phase) };
+        break;
+      case "function_call":
+        slot = {
+          kind: "function_call",
+          id: str2(item.id) ?? "",
+          callId: str2(item.call_id) ?? "",
+          name: str2(item.name) ?? "",
+          args: str2(item.arguments) ?? ""
+        };
+        break;
+      default:
+        slot = { kind: "other", type };
+    }
+    this.slots.set(index, slot);
+    return slot;
+  }
+  /** 项收尾：以厂商给的最终形状为准（reasoning 带 encrypted_content、message 带 id / phase、function_call 带完整 arguments） */
+  finish(index, item) {
+    const slot = this.slotFor(index, item);
+    switch (slot.kind) {
+      case "reasoning":
+        slot.item = item;
+        slot.id = str2(item.id) ?? slot.id;
+        slot.summary = reasoningText(item, slot.summary);
+        break;
+      case "message":
+        slot.id = str2(item.id) ?? slot.id;
+        slot.phase = str2(item.phase) ?? slot.phase;
+        slot.text = messageText(item, slot.text);
+        break;
+      case "function_call":
+        slot.id = str2(item.id) ?? slot.id;
+        slot.callId = str2(item.call_id) ?? slot.callId;
+        slot.name = str2(item.name) ?? slot.name;
+        slot.args = str2(item.arguments) ?? slot.args;
+        break;
+      case "other":
+        break;
+    }
+  }
+  /**
+   * Azure 等上游可能只在 response.completed 的 output 里给 encrypted_content（output_item.done 里没有），
+   * 按 id 回填，让 store:false 的多轮回放不断（pi-ai 同一处置）。
+   */
+  backfill(output) {
+    if (!output) return;
+    for (const item of output) {
+      if (item.type !== "reasoning" || typeof item.encrypted_content !== "string") continue;
+      for (const slot of this.slots.values()) {
+        if (slot.kind !== "reasoning" || slot.id !== item.id) continue;
+        if (!slot.item) slot.item = item;
+        else if (typeof slot.item.encrypted_content !== "string")
+          slot.item = { ...slot.item, encrypted_content: item.encrypted_content };
+      }
+    }
+  }
+  hasFunctionCall() {
+    for (const s of this.slots.values()) if (s.kind === "function_call") return true;
+    return false;
+  }
+  drafts(origin) {
+    const out = [];
+    for (const [, s] of [...this.slots.entries()].sort((x, y) => x[0] - y[0])) {
+      const replay = { ...origin };
+      switch (s.kind) {
+        case "reasoning": {
+          const encrypted = typeof s.item?.encrypted_content === "string" && s.item.encrypted_content.length > 0;
+          if (!encrypted && s.summary.length === 0) break;
+          if (encrypted) replay.thinkingSignature = JSON.stringify(s.item);
+          out.push({ type: "core.model_thinking", actor: "model", payload: { text: s.summary }, replay });
+          break;
+        }
+        case "message":
+          if (s.text.length === 0) break;
+          if (s.id) replay.textSignature = s.id;
+          if (s.phase) replay.phase = s.phase;
+          out.push({ type: "core.model_text", actor: "model", payload: { text: s.text }, replay });
+          break;
+        case "function_call":
+          if (s.id) replay.itemId = s.id;
+          out.push({
+            type: "core.tool_call",
+            actor: "model",
+            payload: { toolCallId: s.callId, name: s.name, args: parseArguments2(s.args) },
+            replay
+          });
+          break;
+        case "other":
+          break;
+      }
+    }
+    return out;
+  }
+};
+function usageOf3(u) {
+  const total = num3(u?.input_tokens) ?? 0;
+  const cached = num3(u?.input_tokens_details?.cached_tokens) ?? 0;
+  const written = num3(u?.input_tokens_details?.cache_write_tokens) ?? 0;
+  const usage = {
+    input: Math.max(0, total - cached - written),
+    output: num3(u?.output_tokens) ?? 0
+  };
+  if (cached > 0) usage.cacheRead = cached;
+  if (written > 0) usage.cacheWrite = written;
+  return usage;
+}
+function apply3(ev, a, ctx) {
+  const type = str2(ev.type);
+  const index = num3(ev.output_index);
+  const slot = index === void 0 ? void 0 : a.slots.get(index);
+  switch (type) {
+    case "response.created":
+    case "response.in_progress": {
+      const id = str2(ev.response?.id);
+      const model = str2(ev.response?.model);
+      if (id) a.responseId = id;
+      if (model) a.responseModel = model;
+      break;
+    }
+    case "response.output_item.added":
+      if (index !== void 0 && ev.item) a.slotFor(index, ev.item);
+      break;
+    case "response.reasoning_summary_part.added":
+      if (slot?.kind === "reasoning" && slot.summary.length > 0 && index !== void 0) {
+        slot.summary += "\n\n";
+        ctx.onDelta?.({ kind: "thinking", index, delta: "\n\n" });
+      }
+      break;
+    case "response.reasoning_summary_text.delta":
+    case "response.reasoning_text.delta": {
+      const d = str2(ev.delta);
+      if (slot?.kind === "reasoning" && d && index !== void 0) {
+        slot.summary += d;
+        ctx.onDelta?.({ kind: "thinking", index, delta: d });
+      }
+      break;
+    }
+    case "response.output_text.delta":
+    case "response.refusal.delta": {
+      const d = str2(ev.delta);
+      if (slot?.kind === "message" && d && index !== void 0) {
+        slot.text += d;
+        ctx.onDelta?.({ kind: "text", index, delta: d });
+      }
+      break;
+    }
+    case "response.function_call_arguments.delta": {
+      const d = str2(ev.delta);
+      if (slot?.kind === "function_call" && d && index !== void 0) {
+        slot.args += d;
+        ctx.onDelta?.({ kind: "tool_args", index, delta: d });
+      }
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      const full = str2(ev.arguments);
+      if (slot?.kind === "function_call" && full !== void 0) slot.args = full;
+      break;
+    }
+    case "response.output_item.done":
+      if (index !== void 0 && ev.item) a.finish(index, ev.item);
+      break;
+    case "response.completed":
+    case "response.incomplete": {
+      a.sawTerminal = true;
+      const r = ev.response;
+      a.status = str2(r?.status) ?? (type === "response.completed" ? "completed" : "incomplete");
+      a.incompleteReason = str2(r?.incomplete_details?.reason);
+      if (r?.usage) a.usage = r.usage;
+      const model = str2(r?.model);
+      if (model) a.responseModel = model;
+      a.backfill(r?.output);
+      break;
+    }
+    case "response.failed": {
+      a.sawTerminal = true;
+      a.status = "failed";
+      const e = ev.response?.error;
+      a.error = {
+        code: str2(e?.code) ?? "failed",
+        message: str2(e?.message) ?? "response.failed carries no error detail"
+      };
+      if (ev.response?.usage) a.usage = ev.response.usage;
+      break;
+    }
+    case "error":
+      a.error = { code: str2(ev.code) ?? "error", message: str2(ev.message) ?? "" };
+      break;
+    default:
+      break;
+  }
+}
+function outcomeOf3(a, cost) {
+  const usage = usageOf3(a.usage);
+  const out = { stopReason: "stop", usage };
+  const c = costOf(usage, cost);
+  if (c !== void 0) out.costUsd = c;
+  if (a.responseModel) out.responseModel = a.responseModel;
+  if (a.error) {
+    out.stopReason = "error";
+    out.errorMessage = `${a.error.code}: ${a.error.message}`;
+    return out;
+  }
+  if (!a.sawTerminal) {
+    out.stopReason = "error";
+    out.errorMessage = "stream ended before response.completed";
+    return out;
+  }
+  if (a.hasFunctionCall()) {
+    out.stopReason = "toolUse";
+    return out;
+  }
+  switch (a.status) {
+    case "completed":
+      break;
+    case "incomplete":
+      if (a.incompleteReason === "max_output_tokens") out.stopReason = "length";
+      else {
+        out.stopReason = "error";
+        out.errorMessage = a.incompleteReason === "content_filter" ? "status=incomplete (content_filter): the provider's content filter cut this output short" : `status=incomplete${a.incompleteReason ? ` (${a.incompleteReason})` : ""}: the provider did not finish`;
+      }
+      break;
+    case "cancelled":
+    case "failed":
+      out.stopReason = "error";
+      out.errorMessage = `status=${a.status}`;
+      break;
+    default:
+      break;
+  }
+  return out;
+}
+async function* consumeResponsesStream(input, ctx = {}) {
+  const a = new ResponsesAssembly();
+  try {
+    for await (const msg of input.messages) {
+      if (msg.data === "[DONE]") break;
+      let ev;
+      try {
+        ev = JSON.parse(msg.data);
+      } catch {
+        continue;
+      }
+      apply3(ev, a, ctx);
+      if (a.error) break;
+    }
+  } catch (err) {
+    yield* a.drafts(input.origin);
+    const base = outcomeOf3(a, input.cost);
+    if (input.signal?.aborted) return { ...base, stopReason: "aborted", errorMessage: "aborted by host" };
+    if (input.timedOut?.())
+      return {
+        ...base,
+        stopReason: "error",
+        errorMessage: `request timed out after ${input.timeoutMs ?? "?"}ms (stream ended before response.completed)`
+      };
+    return { ...base, stopReason: "error", errorMessage: errorText3(err) };
+  }
+  yield* a.drafts(input.origin);
+  return outcomeOf3(a, input.cost);
+}
+function errorText3(err) {
+  if (err instanceof Error) {
+    const cause = err.cause;
+    const code = typeof cause?.code === "string" ? ` (${cause.code})` : "";
+    return `${err.message}${code}`;
+  }
+  return String(err);
+}
+
+// src/responses/to-request.ts
+import {
+  renderToolReference as renderToolReference3
+} from "@reinsjs/core";
+var IMAGE_OMITTED3 = "[image omitted: this model does not accept images]";
+var ERROR_PREFIX2 = "[tool error]\n";
+var EMPTY_NOTE2 = "the content is empty, so no empty message is sent";
+var ENCRYPTED_INCLUDE = "reasoning.encrypted_content";
+function land3(out, e, kind, landing, ...notes) {
+  const note = notes.filter((n) => Boolean(n)).join("; ");
+  out.push(
+    note ? { eventId: e.id, type: e.type, kind, landing, note } : { eventId: e.id, type: e.type, kind, landing }
+  );
+}
+function contentOf(parts, images) {
+  let imagesDropped = false;
+  const content = [];
+  for (const p of parts) {
+    if (p.type === "text") {
+      if (p.text.length > 0) content.push({ type: "input_text", text: p.text });
+    } else if (p.type === "tool_reference") {
+      content.push({ type: "input_text", text: renderToolReference3(p) });
+    } else if (images) {
+      content.push({ type: "input_image", image_url: `data:${p.mime};base64,${p.data}`, detail: "auto" });
+    } else {
+      imagesDropped = true;
+      content.push({ type: "input_text", text: IMAGE_OMITTED3 });
+    }
+  }
+  return { content, imagesDropped };
+}
+function argumentsOf2(args) {
+  return typeof args === "string" ? args : JSON.stringify(args ?? {});
+}
+function textItemId(replay) {
+  const sig = replay.textSignature;
+  if (typeof sig !== "string" || sig.length === 0) return {};
+  const ownPhase = typeof replay.phase === "string" && replay.phase.length > 0 ? { phase: replay.phase } : {};
+  if (sig.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(sig);
+      if (typeof parsed.id === "string" && parsed.id.length > 0) {
+        return typeof parsed.phase === "string" ? { id: parsed.id, phase: parsed.phase } : { id: parsed.id };
+      }
+    } catch {
+    }
+  }
+  return sig.length > 64 ? {} : { id: sig, ...ownPhase };
+}
+function reasoningItemOf(replay) {
+  const sig = replay.thinkingSignature;
+  if (typeof sig !== "string" || !sig.startsWith("{")) return void 0;
+  try {
+    const item = JSON.parse(sig);
+    if (typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0) return void 0;
+    return item;
+  } catch {
+    return void 0;
+  }
+}
+function encodeResponsesRequest(input) {
+  const { model, capabilities } = input;
+  const target = { provider: model.provider, api: model.api, model: model.id };
+  const dialect = model.responses ?? {};
+  const systemRole = dialect.systemRole ?? (model.reasoning ? "developer" : "system");
+  const items = [];
+  const landings = [];
+  let textCounter = 0;
+  if (input.systemPrompt)
+    items.push({ role: systemRole, content: [{ type: "input_text", text: input.systemPrompt }] });
+  for (const item of input.ir) {
+    switch (item.kind) {
+      case "user": {
+        const c = contentOf(item.parts, capabilities.images);
+        if (c.content.length === 0) {
+          land3(landings, item.event, "dropped", "none", EMPTY_NOTE2);
+          break;
+        }
+        items.push({ role: "user", content: c.content });
+        const lossy4 = item.deferred || item.escaped || c.imagesDropped;
+        land3(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          "user",
+          item.deferred ? `the user message sits between a tool call and its results; ${DEFERRED_NOTE}` : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0,
+          c.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0
+        );
+        break;
+      }
+      case "tool_result": {
+        const c = contentOf(item.parts, capabilities.images);
+        const hasImage = c.content.some((b) => b.type === "input_image");
+        const text = c.content.filter((b) => b.type === "input_text").map((b) => b.text).join("\n");
+        const prefixed = item.isError ? ERROR_PREFIX2 + text : text;
+        const output = hasImage ? [
+          ...prefixed.length > 0 ? [{ type: "input_text", text: prefixed }] : [],
+          ...c.content.filter((b) => b.type === "input_image")
+        ] : prefixed;
+        items.push({ type: "function_call_output", call_id: item.toolCallId, output });
+        const lossy4 = item.escaped || item.isError || c.imagesDropped;
+        land3(
+          landings,
+          item.event,
+          lossy4 ? "lossy" : "exact",
+          "function_call_output",
+          item.isError ? "the Responses function_call_output has no error flag, so isError is expressed with a [tool error] prefix" : void 0,
+          c.imagesDropped ? "the model takes no images, so they are replaced with placeholder text" : void 0,
+          item.escaped ? ESCAPED_NOTE : void 0
+        );
+        break;
+      }
+      case "compaction": {
+        items.push({ role: "user", content: [{ type: "input_text", text: framedSummary(item.text) }] });
+        land3(
+          landings,
+          item.event,
+          "lossy",
+          "user-text",
+          "the summary is rendered as user-role text",
+          item.escaped ? ESCAPED_NOTE : void 0,
+          item.deferred ? DEFERRED_NOTE : void 0
+        );
+        break;
+      }
+      case "system_note": {
+        if (capabilities.midConversationSystem) {
+          items.push({ role: systemRole, content: [{ type: "input_text", text: item.text }] });
+          land3(
+            landings,
+            item.event,
+            item.escaped ? "lossy" : "exact",
+            systemRole,
+            item.escaped ? ESCAPED_NOTE : void 0,
+            item.deferred ? DEFERRED_NOTE : void 0
+          );
+        } else {
+          items.push({
+            role: "user",
+            content: [{ type: "input_text", text: framedSystemNote(item.noteKind, item.text) }]
+          });
+          land3(
+            landings,
+            item.event,
+            "lossy",
+            "user-role",
+            "the host declared that this upstream does not support mid-conversation system, so it is wrapped in a <system_note> tag and sent with the user role",
+            item.escaped ? ESCAPED_NOTE : void 0,
+            item.deferred ? DEFERRED_NOTE : void 0
+          );
+        }
+        break;
+      }
+      case "assistant": {
+        const out = assistantItems(
+          item.blocks,
+          item.origin,
+          target,
+          landings,
+          () => `msg_reins_${++textCounter}`
+        );
+        items.push(...out);
+        break;
+      }
+      case "dropped":
+        land3(landings, item.event, "dropped", "none", item.note);
+        break;
+    }
+  }
+  const ro = input.requestOptions ?? {};
+  const { input: _input, tools: _tools, previous_response_id: _prev, ...passthrough } = ro;
+  const body = {
+    ...passthrough,
+    model: model.id,
+    input: items,
+    stream: true,
+    store: false
+  };
+  const shownTools = (input.tools ?? []).filter((t) => t.deferLoading !== true);
+  if (shownTools.length > 0) {
+    body.tools = shownTools.map(
+      (t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
+        strict: false
+      })
+    );
+  }
+  if (model.reasoning && dialect.encryptedReasoning !== false) {
+    const hostInclude = Array.isArray(ro.include) ? ro.include.filter((x) => typeof x === "string") : [];
+    body.include = hostInclude.includes(ENCRYPTED_INCLUDE) ? hostInclude : [...hostInclude, ENCRYPTED_INCLUDE];
+  }
+  return { body, landings: orderLandings(input.events, landings) };
+}
+function assistantItems(blocks, origin, target, landings, nextTextId) {
+  const out = [];
+  const foreign = foreignOrigin(origin, target);
+  const sameModel = !foreign && origin.model === target.model;
+  for (const b of blocks) {
+    switch (b.type) {
+      case "text": {
+        if (b.text.length === 0) {
+          land3(landings, b.event, "dropped", "none", EMPTY_NOTE2);
+          break;
+        }
+        const own = foreign ? {} : textItemId(b.replay);
+        const id = own.id ?? nextTextId();
+        out.push({
+          type: "message",
+          role: "assistant",
+          id,
+          status: "completed",
+          content: [{ type: "output_text", text: b.text, annotations: [] }],
+          ...own.phase !== void 0 ? { phase: own.phase } : {}
+        });
+        land3(
+          landings,
+          b.event,
+          "exact",
+          "assistant-message",
+          own.id === void 0 ? "the item id is supplied by this package" : void 0
+        );
+        break;
+      }
+      case "thinking": {
+        if (foreign) {
+          land3(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            `reasoning from ${origin.provider}/${origin.api} has no encrypted item of its own, so it is not replayed`
+          );
+          break;
+        }
+        if (!sameModel) {
+          land3(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            `the reasoning item comes from ${origin.model}, but this request targets ${target.model}; encrypted reasoning is only valid for the model that produced it, so it is not replayed`
+          );
+          break;
+        }
+        const item = reasoningItemOf(b.replay);
+        if (!item) {
+          land3(
+            landings,
+            b.event,
+            "dropped",
+            "none",
+            "the reasoning item has no encrypted_content (it was not requested, or the stream broke), so it cannot be replayed under store:false"
+          );
+          break;
+        }
+        out.push({ ...item, type: "reasoning" });
+        land3(landings, b.event, "exact", "reasoning-item");
+        break;
+      }
+      case "tool_call": {
+        const itemId = sameModel && typeof b.replay.itemId === "string" ? b.replay.itemId : void 0;
+        out.push({
+          type: "function_call",
+          ...itemId !== void 0 ? { id: itemId } : {},
+          call_id: b.id,
+          name: b.name,
+          arguments: argumentsOf2(b.args)
+        });
+        land3(
+          landings,
+          b.event,
+          "exact",
+          "function_call",
+          itemId === void 0 && typeof b.replay.itemId === "string" ? "the model changed, so the fc_ item id is not carried back" : void 0
+        );
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+// src/sse.ts
+async function* parseSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event;
+  let id;
+  const data = [];
+  const flush = () => {
+    const msg = { data: data.join("\n") };
+    if (event !== void 0) msg.event = event;
+    if (id !== void 0) msg.id = id;
+    const empty = data.length === 0 && event === void 0;
+    event = void 0;
+    id = void 0;
+    data.length = 0;
+    return empty ? void 0 : msg;
+  };
+  const line = (raw) => {
+    if (raw === "") return flush();
+    if (raw.startsWith(":")) return void 0;
+    const colon = raw.indexOf(":");
+    const field = colon === -1 ? raw : raw.slice(0, colon);
+    let value = colon === -1 ? "" : raw.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "data":
+        data.push(value);
+        break;
+      case "event":
+        event = value;
+        break;
+      case "id":
+        id = value;
+        break;
+      default:
+        break;
+    }
+    return void 0;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+      let start = 0;
+      while (true) {
+        const nl = buffer.indexOf("\n", start);
+        const cr = buffer.indexOf("\r", start);
+        let end = -1;
+        let skip = 1;
+        if (nl === -1 && cr === -1) break;
+        if (cr !== -1 && (nl === -1 || cr < nl)) {
+          end = cr;
+          if (cr === buffer.length - 1 && !done) break;
+          if (buffer[cr + 1] === "\n") skip = 2;
+        } else end = nl;
+        const msg = line(buffer.slice(start, end));
+        if (msg) yield msg;
+        start = end + skip;
+      }
+      buffer = buffer.slice(start);
+      if (done) break;
+    }
+    if (buffer !== "") {
+      const msg = line(buffer);
+      if (msg) yield msg;
+    }
+    const tail = flush();
+    if (tail) yield tail;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/lowering.ts
+var ANTHROPIC_VERSION = "2023-06-01";
+var FetchLowering = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.extraModels = opts.models ?? [];
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  opts;
+  extraModels;
+  timeoutMs;
+  capabilities(ref) {
+    return capabilitiesOf(resolveModel(ref, this.extraModels));
+  }
+  toRequest(input) {
+    const model = resolveModel(input.model, this.extraModels);
+    const capabilities = capabilitiesOf(model);
+    const ir = eventsToIr({
+      events: input.events,
+      target: { provider: model.provider, api: model.api, model: model.id },
+      ...this.opts.trustMarkers !== void 0 ? { trustMarkers: this.opts.trustMarkers } : {}
+    });
+    const requestOptions = this.opts.requestOptions?.(input.model);
+    const encodeInput = {
+      ir,
+      events: input.events,
+      model,
+      capabilities,
+      ...input.tools ? { tools: input.tools } : {},
+      ...input.systemPrompt !== void 0 ? { systemPrompt: input.systemPrompt } : {},
+      ...requestOptions ? { requestOptions } : {}
+    };
+    switch (model.api) {
+      case "openai-chat": {
+        const { body, landings } = encodeChatRequest(encodeInput);
+        return { model: input.model, capabilities, landings, payload: { api: model.api, body } };
+      }
+      case "anthropic-messages": {
+        const { body, landings } = encodeAnthropicRequest(encodeInput);
+        return { model: input.model, capabilities, landings, payload: { api: model.api, body } };
+      }
+      case "openai-responses": {
+        const { body, landings } = encodeResponsesRequest(encodeInput);
+        return { model: input.model, capabilities, landings, payload: { api: model.api, body } };
+      }
+      default:
+        throw new LoweringError2("unsupported_api", `unsupported wire protocol ${model.api}`, {
+          api: model.api
+        });
+    }
+  }
+  async *stream(req, ctx = {}) {
+    const model = resolveModel(req.model, this.extraModels);
+    const headers = this.headersFor(model);
+    const signals = requestSignals(ctx.signal, this.timeoutMs);
+    const res = await postJson({
+      url: endpointOf(model),
+      headers,
+      body: req.payload.body,
+      signal: signals.signal,
+      ...this.opts.fetch ? { fetch: this.opts.fetch } : {}
+    });
+    if (!res.body) {
+      return {
+        stopReason: "error",
+        usage: { input: 0, output: 0 },
+        errorMessage: "the response has no body"
+      };
+    }
+    const streamInput = {
+      messages: parseSse(res.body),
+      origin: { provider: model.provider, api: model.api, model: model.id },
+      ...model.cost ? { cost: model.cost } : {},
+      ...ctx.signal ? { signal: ctx.signal } : {},
+      timedOut: signals.timedOut,
+      timeoutMs: this.timeoutMs
+    };
+    switch (req.payload.api) {
+      case "openai-chat":
+        return yield* consumeChatStream(streamInput, ctx);
+      case "anthropic-messages":
+        return yield* consumeAnthropicStream(streamInput, ctx);
+      case "openai-responses":
+        return yield* consumeResponsesStream(streamInput, ctx);
+      default:
+        throw new LoweringError2("unsupported_api", `unsupported wire protocol ${req.payload.api}`, {
+          api: req.payload.api
+        });
+    }
+  }
+  /**
+   * 鉴权头按协议缺省（Chat / Responses bearer、Anthropic x-api-key），模型声明 auth:"none" 时凭证由 headers 自带。
+   * Anthropic 线固定带 `anthropic-version`，`anthropic-beta` 只在模型声明了 betas 时带（F0 结论：用到才带）；模型级 headers 最后盖。
+   */
+  headersFor(model) {
+    const protocol = {};
+    if (model.api === "anthropic-messages") {
+      protocol["anthropic-version"] = ANTHROPIC_VERSION;
+      const betas = model.anthropic?.betas;
+      if (betas && betas.length > 0) protocol["anthropic-beta"] = betas.join(",");
+    }
+    const headers = { ...this.opts.headers, ...protocol, ...model.headers };
+    const auth = model.auth ?? (model.api === "anthropic-messages" ? "x-api-key" : "bearer");
+    if (auth === "none") return headers;
+    const apiKey = this.opts.apiKey(model.provider);
+    if (!apiKey) {
+      throw new LoweringError2("missing_api_key", `no API key configured for ${model.provider}`, {
+        provider: model.provider
+      });
+    }
+    if (auth === "bearer") headers.authorization = `Bearer ${apiKey}`;
+    else headers["x-api-key"] = apiKey;
+    return headers;
+  }
+};
+
+// src/factories.ts
+var DEFAULTS = { contextWindow: 128e3, maxOutputTokens: 16384, reasoning: false, images: false };
+function defined(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+function definitionOf(provider, id, api, opts) {
+  const builtin = findBuiltin(provider, id, api);
+  const base = builtin ?? { provider, id, api, baseUrl: opts.baseUrl ?? "", ...DEFAULTS };
+  if (!builtin && !opts.baseUrl) {
+    throw new RangeError(`model ${provider}/${id} is not in the built-in table, so baseUrl is required`);
+  }
+  const chat = base.chat || opts.chat ? { ...base.chat, ...defined(opts.chat ?? {}) } : void 0;
+  const anthropic2 = base.anthropic || opts.anthropic ? { ...base.anthropic, ...defined(opts.anthropic ?? {}) } : void 0;
+  const responses = base.responses || opts.responses ? { ...base.responses, ...defined(opts.responses ?? {}) } : void 0;
+  return {
+    ...base,
+    ...defined({
+      baseUrl: opts.baseUrl,
+      contextWindow: opts.contextWindow,
+      maxOutputTokens: opts.maxOutputTokens,
+      reasoning: opts.reasoning,
+      images: opts.images,
+      cost: opts.cost,
+      midConversationSystem: opts.midConversationSystem,
+      auth: opts.auth,
+      headers: opts.headers
+    }),
+    ...chat ? { chat } : {},
+    ...anthropic2 ? { anthropic: anthropic2 } : {},
+    ...responses ? { responses } : {}
+  };
+}
+function bound(provider, id, model, opts) {
+  const loweringOpts = {
+    apiKey: (p) => p === provider ? opts.apiKey : void 0,
+    models: [model],
+    ...opts.requestOptions ? { requestOptions: () => opts.requestOptions ?? {} } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+    ...opts.trustMarkers !== void 0 ? { trustMarkers: opts.trustMarkers } : {}
+  };
+  return { model: { provider, id }, lowering: new FetchLowering(loweringOpts) };
+}
+function chatCompletions(id, opts) {
+  return bound(opts.provider, id, definitionOf(opts.provider, id, "openai-chat", opts), opts);
+}
+function deepseek(id, opts) {
+  return chatCompletions(id, {
+    provider: "deepseek",
+    baseUrl: "https://api.deepseek.com",
+    reasoning: true,
+    images: true,
+    ...opts,
+    chat: { reasoningContent: true, ...opts.chat }
+  });
+}
+function openaiChat(id, opts) {
+  return chatCompletions(id, { provider: "openai", baseUrl: "https://api.openai.com/v1", ...opts });
+}
+function openaiResponses(id, opts) {
+  return bound(opts.provider, id, definitionOf(opts.provider, id, "openai-responses", opts), opts);
+}
+function openai(id, opts) {
+  const unknown = findBuiltin("openai", id, "openai-responses") === void 0;
+  return openaiResponses(id, {
+    provider: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    ...unknown ? { reasoning: true, images: true } : {},
+    ...opts
+  });
+}
+function anthropicMessages(id, opts) {
+  return bound(opts.provider, id, definitionOf(opts.provider, id, "anthropic-messages", opts), opts);
+}
+function anthropic(id, opts) {
+  return anthropicMessages(id, {
+    provider: "anthropic",
+    baseUrl: "https://api.anthropic.com/v1",
+    reasoning: true,
+    images: true,
+    ...opts
+  });
+}
+
+// src/responses/loss-matrix.ts
+var exact3 = (landing, note, when) => {
+  const spec = { kind: "exact", landing };
+  if (note) spec.note = note;
+  if (when) spec.when = when;
+  return spec;
+};
+var lossy3 = (landing, note, when) => when ? { kind: "lossy", landing, note, when } : { kind: "lossy", landing, note };
+var dropped3 = (landing, note, when) => when ? { kind: "dropped", landing, note, when } : { kind: "dropped", landing, note };
+var RESPONSES_LOSS_MATRIX = {
+  "core.user_message": [
+    exact3("user", "a user message in input, as input_text / input_image blocks"),
+    lossy3(
+      "user",
+      "moved after that batch of tool results (the order changes), untrusted content escaped, or images replaced with placeholder text because the model takes none",
+      "the user speaks up before all tool results are in / the content holds a </untrusted / it carries images the model does not take"
+    ),
+    dropped3(
+      "none",
+      "the content is empty, so no empty message is sent",
+      "the user message has no non-empty content"
+    )
+  ],
+  "core.model_text": [
+    exact3(
+      "assistant-message",
+      "a type:message assistant output item; each text segment of a turn becomes its own item; the item id is replayed when it comes from the same model, otherwise a new one is made up"
+    ),
+    dropped3("none", "empty text is not sent", "the text is an empty string")
+  ],
+  "core.model_thinking": [
+    exact3(
+      "reasoning-item",
+      "the whole reasoning item (including encrypted_content) is replayed verbatim",
+      "replay.thinkingSignature is a reasoning item with encrypted_content and comes from the same source (provider + api + model)"
+    ),
+    dropped3(
+      "none",
+      "reasoning with no encrypted_content (the encrypted item was not requested, or the stream broke), from another source, or from another model of the same family (encrypted reasoning is only valid for the model that produced it) cannot be replayed, and is not downgraded to text"
+    )
+  ],
+  "core.tool_call": [
+    exact3(
+      "function_call",
+      "arguments is a JSON string, and non-object arguments are serialized as they are; the fc_ item id is replayed only for the same model (to stay clear of the pairing check)"
+    )
+  ],
+  "core.tool_result": [
+    exact3(
+      "function_call_output",
+      "matched by call_id; output is a string for text, or an array of content blocks when images are present; tool reference parts are expanded into text (Responses has no deferred-loading landing)"
+    ),
+    lossy3(
+      "function_call_output",
+      "isError is expressed with a [tool error] prefix (the protocol has no error flag), or untrusted content is escaped, or images are replaced with placeholder text because the model takes none"
+    )
+  ],
+  "core.system_note": [
+    exact3(
+      "developer",
+      "a developer message anywhere in input",
+      "a reasoning model (or responses.systemRole = developer)"
+    ),
+    exact3(
+      "system",
+      "a system message anywhere in input",
+      "a non-reasoning model (or responses.systemRole = system)"
+    ),
+    lossy3(
+      "developer",
+      "a developer message, with the early close inside untrusted content escaped",
+      "a note the host marked untrusted holds a </untrusted"
+    ),
+    lossy3(
+      "system",
+      "a system message, with the early close inside untrusted content escaped",
+      "same as above"
+    ),
+    lossy3(
+      "user-role",
+      "wrapped in a <system_note> tag and sent with the user role",
+      "the host declared midConversationSystem: false for an unusual upstream"
+    )
+  ],
+  "core.compaction": [
+    lossy3(
+      "user-text",
+      "the summary is rendered as user-role text, so the model cannot tell it apart from the user's own words"
+    )
+  ],
+  ...NOT_SENT
+};
+
+// src/index.ts
+var LOSS_MATRIX = {
+  "openai-chat": CHAT_LOSS_MATRIX,
+  "anthropic-messages": ANTHROPIC_LOSS_MATRIX,
+  "openai-responses": RESPONSES_LOSS_MATRIX
+};
+function declaredLandings(api, type) {
+  const table = LOSS_MATRIX[api];
+  if (!table) return [];
+  return table[type] ?? (type.startsWith("ext.") ? table["ext.*"] ?? [] : []);
+}
+export {
+  ANTHROPIC_LOSS_MATRIX,
+  ANTHROPIC_VERSION,
+  BUILTIN_MODELS,
+  CHAT_LOSS_MATRIX,
+  DEFAULT_TIMEOUT_MS,
+  FetchLowering,
+  HttpError,
+  LOSS_MATRIX,
+  MAX_ANTHROPIC_BREAKPOINTS,
+  RESPONSES_LOSS_MATRIX,
+  SUPPORTED_APIS,
+  anthropic,
+  anthropicMessages,
+  usageOf as anthropicUsageOf,
+  capabilitiesOf,
+  chatCompletions,
+  usageOf2 as chatUsageOf,
+  consumeAnthropicStream,
+  consumeChatStream,
+  consumeResponsesStream,
+  costOf,
+  declaredLandings,
+  deepseek,
+  definitionOf,
+  encodeAnthropicRequest,
+  encodeChatRequest,
+  encodeResponsesRequest,
+  endpointOf,
+  eventsToIr,
+  findBuiltin,
+  foreignOrigin,
+  openai,
+  openaiChat,
+  openaiResponses,
+  orderLandings,
+  parseSse,
+  postJson,
+  reasoningItemOf,
+  requestSignals,
+  resolveModel,
+  usageOf3 as responsesUsageOf,
+  sameOrigin
+};
+//# sourceMappingURL=index.js.map