llm-stream-assemble 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2238 @@
+'use strict';
+
+// src/core/utils/bytes.ts
+var Utf8StreamDecoder = class {
+  decoder = new TextDecoder();
+  decode(chunk) {
+    return this.decoder.decode(chunk, { stream: true });
+  }
+  flush() {
+    return this.decoder.decode();
+  }
+};
+var encoder = new TextEncoder();
+function utf8ByteLength(value) {
+  return encoder.encode(value).byteLength;
+}
+
+// src/core/utils/source.ts
+async function* readableStreamToStrings(source) {
+  const reader = source.getReader();
+  const decoder = new Utf8StreamDecoder();
+  let completed = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        completed = true;
+        break;
+      }
+      const decoded = decoder.decode(value);
+      if (decoded.length > 0) {
+        yield decoded;
+      }
+    }
+    const flushed = decoder.flush();
+    if (flushed.length > 0) {
+      yield flushed;
+    }
+  } finally {
+    if (!completed) {
+      await reader.cancel().catch(() => void 0);
+    }
+    reader.releaseLock();
+  }
+}
+function isReadableStream(source) {
+  return typeof source.getReader === "function";
+}
+function sourceToStrings(source) {
+  return isReadableStream(source) ? readableStreamToStrings(source) : source;
+}
+function errorFromUnknown(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function prefixedError(message) {
+  return new Error(`llm-stream-assemble: ${message}`);
+}
+
+// src/core/assembly/process-payload.ts
+function isDoneMarker(payload) {
+  return payload.trim() === "[DONE]";
+}
+function processPayload(payload, assembler, adapter, options) {
+  if (isDoneMarker(payload)) {
+    return { kind: "done-marker" };
+  }
+  let chunks;
+  try {
+    chunks = adapter.parseChunk(payload);
+  } catch (error) {
+    if (!options.recoverMalformed) {
+      throw error;
+    }
+    return {
+      kind: "recoverable-error",
+      event: {
+        type: "error",
+        error: prefixedError(errorFromUnknown(error).message),
+        recoverable: true
+      }
+    };
+  }
+  const events = [];
+  for (const chunk of chunks) {
+    events.push(...assembler.push(chunk));
+  }
+  return { kind: "events", events };
+}
+function resolveTerminalFlush(assembler, state) {
+  if (state.aborted) {
+    return assembler.flush({ terminalReason: "aborted" });
+  }
+  if (state.sawTerminalMarker) {
+    return assembler.flush({ terminalReason: "stop" });
+  }
+  if (assembler.hasFinished()) {
+    return assembler.flush();
+  }
+  return assembler.flush({ terminalReason: "incomplete" });
+}
+
+// src/core/parse-partial-json.ts
+function parsePartialJSON(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    return { complete: false };
+  }
+  const complete = parseComplete(trimmed);
+  if (complete.ok) {
+    return { complete: true, value: complete.value };
+  }
+  const end = findFirstCompleteValueEnd(trimmed);
+  if (end !== void 0) {
+    const parsed = parseComplete(trimmed.slice(0, end));
+    if (parsed.ok) {
+      return { complete: false, value: parsed.value };
+    }
+  }
+  for (const candidate of repairedCandidates(trimmed)) {
+    const parsed = parseComplete(candidate);
+    if (parsed.ok) {
+      return { complete: false, value: parsed.value };
+    }
+  }
+  return { complete: false };
+}
+function parseComplete(input) {
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch {
+    return { ok: false };
+  }
+}
+function findFirstCompleteValueEnd(input) {
+  let inString = false;
+  let escaped = false;
+  const stack = [];
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+        if (stack.length === 0) {
+          return index + 1;
+        }
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+    } else if (char === "{" || char === "[") {
+      stack.push(char === "{" ? "}" : "]");
+    } else if (char === "}" || char === "]") {
+      if (stack.pop() !== char) return void 0;
+      if (stack.length === 0) {
+        return index + 1;
+      }
+    } else if (stack.length === 0 && isPrimitiveTerminator(input, index)) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function isPrimitiveTerminator(input, index) {
+  if (!/[\s,}\]]/.test(input[index] ?? "")) return false;
+  const prefix = input.slice(0, index).trim();
+  if (prefix.length === 0) return false;
+  return parseComplete(prefix).ok;
+}
+function repairedCandidates(input) {
+  const candidates = /* @__PURE__ */ new Set();
+  const base = closeContainers(closeOpenString(input));
+  candidates.add(base);
+  for (const trimmed of trimDanglingValues(input)) {
+    candidates.add(closeContainers(closeOpenString(trimmed)));
+  }
+  return [...candidates];
+}
+function closeOpenString(input) {
+  let inString = false;
+  let escaped = false;
+  for (const char of input) {
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+    } else if (char === '"') {
+      inString = true;
+    }
+  }
+  if (!inString) return input;
+  return escaped ? `${input.slice(0, -1)}"` : `${input}"`;
+}
+function closeContainers(input) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (const char of input) {
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+    } else if (char === "{" || char === "[") {
+      stack.push(char === "{" ? "}" : "]");
+    } else if ((char === "}" || char === "]") && stack.at(-1) === char) {
+      stack.pop();
+    }
+  }
+  return `${input}${stack.reverse().join("")}`;
+}
+function trimDanglingValues(input) {
+  const variants = [];
+  let current = input.trimEnd();
+  while (current.length > 0) {
+    const last = current.at(-1);
+    if (last === "," || last === ":") {
+      current = current.slice(0, -1).trimEnd();
+      variants.push(current);
+      continue;
+    }
+    const colon = lastTopLevelToken(current, ":");
+    const comma = lastTopLevelToken(current, ",");
+    const openObject = lastTopLevelToken(current, "{");
+    const cutAt = Math.max(colon, comma, openObject);
+    if (cutAt === -1) break;
+    current = current.slice(0, cutAt + (current[cutAt] === "{" ? 1 : 0)).trimEnd();
+    variants.push(current);
+    break;
+  }
+  return variants;
+}
+function lastTopLevelToken(input, token) {
+  let inString = false;
+  let escaped = false;
+  let depth = 0;
+  for (let index = input.length - 1; index >= 0; index -= 1) {
+    const char = input[index];
+    if (inString) {
+      if (char === "\\" && !escaped) {
+        escaped = true;
+      } else if (char === '"' && !escaped) {
+        inString = false;
+      } else {
+        escaped = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+    } else if (char === "}" || char === "]") {
+      depth += 1;
+    } else if (char === "{" || char === "[") {
+      if (depth === 0 && char === token) return index;
+      depth -= 1;
+    } else if (depth === 0 && char === token) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+// src/core/assembler/event-assembler.ts
+var EventAssembler = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  text = /* @__PURE__ */ new Map();
+  reasoning = "";
+  reasoningVariant;
+  refusal = "";
+  json = "";
+  tools = /* @__PURE__ */ new Map();
+  toolByIndex = /* @__PURE__ */ new Map();
+  finishEmitted = false;
+  push(chunk) {
+    if (this.finishEmitted) return [];
+    switch (chunk.kind) {
+      case "message-start":
+        return [
+          optionalEvent({ type: "message.start", id: chunk.id, choiceIndex: chunk.choiceIndex })
+        ];
+      case "text-delta":
+        return this.pushText(chunk.text, chunk.choiceIndex);
+      case "reasoning-delta":
+        return this.pushReasoning(chunk.text, chunk.variant);
+      case "refusal-delta":
+        return this.pushRefusal(chunk.text);
+      case "json-delta":
+        return this.pushJson(chunk.delta);
+      case "tool-start":
+        return this.pushToolStart(chunk);
+      case "tool-args-delta":
+        return this.pushToolArgs(chunk);
+      case "tool-done":
+        return this.finishTool(chunk);
+      case "metadata": {
+        const { kind: _kind, ...metadata } = chunk;
+        return [optionalEvent({ type: "metadata", ...metadata })];
+      }
+      case "usage": {
+        const { kind: _kind, ...usage } = chunk;
+        return [optionalEvent({ type: "usage", ...usage })];
+      }
+      case "finish":
+        return chunk.choiceIndex === void 0 ? this.flush({ terminalReason: chunk.reason }) : this.flush({ terminalReason: chunk.reason, choiceIndex: chunk.choiceIndex });
+      case "provider-error":
+        return [this.errorEvent(chunk.error, chunk.recoverable)];
+    }
+  }
+  flush(options = {}) {
+    const events = [];
+    events.push(...this.flushText());
+    events.push(...this.flushReasoning());
+    events.push(...this.flushRefusal());
+    events.push(...this.flushJson());
+    events.push(...this.flushTools());
+    const forcedError = events.some(
+      (event) => event.type === "error" && event.recoverable === false
+    );
+    const reason = forcedError ? "error" : options.terminalReason;
+    if (reason && !this.finishEmitted) {
+      events.push(optionalEvent({ type: "finish", reason, choiceIndex: options.choiceIndex }));
+      this.finishEmitted = true;
+    }
+    return events;
+  }
+  reset() {
+    this.text = /* @__PURE__ */ new Map();
+    this.reasoning = "";
+    this.reasoningVariant = void 0;
+    this.refusal = "";
+    this.json = "";
+    this.tools.clear();
+    this.toolByIndex.clear();
+    this.finishEmitted = false;
+  }
+  hasFinished() {
+    return this.finishEmitted;
+  }
+  pushText(text, choiceIndex = 0) {
+    if (text.length === 0) return [];
+    const next = `${this.text.get(choiceIndex) ?? ""}${text}`;
+    this.assertBuffer(next, "text");
+    this.text.set(choiceIndex, next);
+    return [
+      optionalEvent({ type: "text.delta", text, choiceIndex: normalizeChoiceIndex(choiceIndex) })
+    ];
+  }
+  pushReasoning(text, variant) {
+    if (text.length === 0) return [];
+    this.reasoning += text;
+    this.reasoningVariant = variant ?? this.reasoningVariant;
+    this.assertBuffer(this.reasoning, "reasoning");
+    return [optionalEvent({ type: "reasoning.delta", text, variant })];
+  }
+  pushRefusal(text) {
+    if (text.length === 0) return [];
+    this.refusal += text;
+    this.assertBuffer(this.refusal, "refusal");
+    return [{ type: "refusal.delta", text }];
+  }
+  pushJson(delta) {
+    if (delta.length === 0) return [];
+    this.json += delta;
+    this.assertBuffer(this.json, "json");
+    const partial = parsePartialJSON(this.json);
+    return [withOptional("partial", partial.value, { type: "json.delta", delta })];
+  }
+  pushToolStart(chunk) {
+    const state = this.getOrCreateTool(chunk);
+    if (chunk.id && !state.started) {
+      state.eventId = chunk.id;
+    }
+    state.name = chunk.name;
+    state.index = chunk.index;
+    state.choiceIndex = chunk.choiceIndex;
+    if (state.started) return [];
+    state.started = true;
+    return [
+      optionalEvent({
+        type: "tool_call.start",
+        id: state.eventId,
+        name: state.name,
+        index: state.index,
+        choiceIndex: state.choiceIndex
+      })
+    ];
+  }
+  pushToolArgs(chunk) {
+    if (chunk.delta.length === 0) return [];
+    const state = this.getOrCreateTool(chunk);
+    state.args += chunk.delta;
+    this.assertBuffer(state.args, "tool args");
+    const partial = parsePartialJSON(state.args);
+    return [
+      withOptional("partial", partial.value, {
+        type: "tool_call.args.delta",
+        id: state.eventId,
+        delta: chunk.delta
+      })
+    ];
+  }
+  finishTool(chunk) {
+    const state = this.getOrCreateTool(chunk);
+    const done = this.toolDoneEvent(state);
+    this.deleteTool(state);
+    return [done];
+  }
+  flushText() {
+    const events = [];
+    for (const [choiceIndex, text] of this.text) {
+      if (text.length > 0) {
+        events.push(
+          optionalEvent({
+            type: "text.done",
+            text,
+            choiceIndex: normalizeChoiceIndex(choiceIndex)
+          })
+        );
+      }
+    }
+    this.text.clear();
+    return events;
+  }
+  flushReasoning() {
+    if (this.reasoning.length === 0) return [];
+    const event = optionalEvent({
+      type: "reasoning.done",
+      text: this.reasoning,
+      variant: this.reasoningVariant
+    });
+    this.reasoning = "";
+    this.reasoningVariant = void 0;
+    return [event];
+  }
+  flushRefusal() {
+    if (this.refusal.length === 0) return [];
+    const event = { type: "refusal.done", text: this.refusal };
+    this.refusal = "";
+    return [event];
+  }
+  flushJson() {
+    if (this.json.length === 0) return [];
+    const parsed = parsePartialJSON(this.json);
+    this.json = "";
+    if (parsed.complete) {
+      return [{ type: "json.done", value: parsed.value }];
+    }
+    return [this.errorEvent(prefixedError("json stream ended with invalid JSON"), false)];
+  }
+  flushTools() {
+    const events = [];
+    for (const state of this.tools.values()) {
+      events.push(this.toolDoneEvent(state));
+    }
+    this.tools.clear();
+    this.toolByIndex.clear();
+    return events;
+  }
+  toolDoneEvent(state) {
+    const parsed = parsePartialJSON(state.args);
+    if (parsed.complete) {
+      return { type: "tool_call.done", id: state.eventId, name: state.name, args: parsed.value };
+    }
+    if (this.options.strictToolArgs) {
+      throw prefixedError(`tool args for ${state.name} ended with invalid JSON`);
+    }
+    return { type: "tool_call.done", id: state.eventId, name: state.name, args: state.args };
+  }
+  getOrCreateTool(chunk) {
+    const choiceIndex = chunk.choiceIndex ?? 0;
+    const indexKey = chunk.index === void 0 ? void 0 : `${choiceIndex}:${chunk.index}`;
+    let key = (indexKey ? this.toolByIndex.get(indexKey) : void 0) || chunk.id;
+    if (!key && indexKey) {
+      key = `tool:${indexKey}`;
+      this.toolByIndex.set(indexKey, key);
+    }
+    key ??= chunk.id ?? `tool:${choiceIndex}:${this.tools.size}`;
+    let state = this.tools.get(key);
+    if (!state) {
+      state = {
+        eventId: chunk.id || key,
+        name: "unknown",
+        args: "",
+        index: chunk.index,
+        choiceIndex: normalizeChoiceIndex(choiceIndex),
+        started: false
+      };
+      this.tools.set(key, state);
+    }
+    if (chunk.id && !state.started && state.eventId.startsWith("tool:")) {
+      this.tools.delete(key);
+      state.eventId = chunk.id;
+      this.tools.set(chunk.id, state);
+      if (indexKey) {
+        this.toolByIndex.set(indexKey, chunk.id);
+      }
+    }
+    return state;
+  }
+  deleteTool(state) {
+    this.tools.delete(state.eventId);
+    if (state.index !== void 0) {
+      this.toolByIndex.delete(`${state.choiceIndex ?? 0}:${state.index}`);
+    }
+  }
+  assertBuffer(value, label) {
+    if (this.options.maxBufferBytes === void 0) return;
+    if (utf8ByteLength(value) > this.options.maxBufferBytes) {
+      throw prefixedError(`${label} buffer exceeded maxBufferBytes`);
+    }
+  }
+  errorEvent(error, recoverable) {
+    const source = errorFromUnknown(error);
+    if (!this.options.sanitizeErrors) {
+      return optionalEvent({ type: "error", error: source, recoverable });
+    }
+    return optionalEvent({
+      type: "error",
+      error: new Error("An error occurred while processing the stream."),
+      recoverable,
+      sanitized: "An error occurred while processing the stream."
+    });
+  }
+};
+function optionalEvent(event) {
+  return Object.fromEntries(
+    Object.entries(event).filter(([, value]) => value !== void 0 && value !== "kind")
+  );
+}
+function withOptional(key, value, target) {
+  if (value === void 0) return target;
+  return { ...target, [key]: value };
+}
+function normalizeChoiceIndex(choiceIndex) {
+  return choiceIndex === 0 ? void 0 : choiceIndex;
+}
+
+// src/core/assemble-payloads.ts
+function assembleFromPayloads(payloads, adapter, options = {}) {
+  return assembleFromPayloadsGenerator(payloads, adapter, options);
+}
+async function* assembleFromPayloadsGenerator(payloads, adapter, options) {
+  const assembler = new EventAssembler(options);
+  const iterator = payloads[Symbol.asyncIterator]();
+  let sawTerminalMarker = false;
+  try {
+    while (true) {
+      if (options.signal?.aborted) {
+        yield* assembler.flush({ terminalReason: "aborted" });
+        return;
+      }
+      const item = await iterator.next();
+      if (item.done) break;
+      const result = processPayload(item.value, assembler, adapter, options);
+      if (result.kind === "done-marker") {
+        sawTerminalMarker = true;
+        continue;
+      }
+      if (result.kind === "recoverable-error") {
+        yield result.event;
+        continue;
+      }
+      yield* result.events;
+    }
+    yield* resolveTerminalFlush(assembler, {
+      sawTerminalMarker,
+      aborted: options.signal?.aborted === true
+    });
+  } finally {
+    await iterator.return?.();
+  }
+}
+
+// src/core/utils/sse-parser.ts
+var SSEParser = class {
+  lineBuffer = "";
+  dataLines = [];
+  push(chunk) {
+    const payloads = [];
+    this.lineBuffer += chunk;
+    while (true) {
+      const lineEnd = this.findLineEnd();
+      if (!lineEnd) break;
+      const line = this.lineBuffer.slice(0, lineEnd.index);
+      this.lineBuffer = this.lineBuffer.slice(lineEnd.nextIndex);
+      const payload = this.processLine(line);
+      if (payload !== void 0) {
+        payloads.push(payload);
+      }
+    }
+    return payloads;
+  }
+  flush() {
+    const payloads = [];
+    if (this.lineBuffer.length > 0) {
+      const payload2 = this.processLine(this.lineBuffer);
+      this.lineBuffer = "";
+      if (payload2 !== void 0) {
+        payloads.push(payload2);
+      }
+    }
+    const payload = this.dispatch();
+    if (payload !== void 0) {
+      payloads.push(payload);
+    }
+    return payloads;
+  }
+  findLineEnd() {
+    const lf = this.lineBuffer.indexOf("\n");
+    const cr = this.lineBuffer.indexOf("\r");
+    if (lf === -1 && cr === -1) return void 0;
+    if (cr !== -1 && (lf === -1 || cr < lf)) {
+      const nextIndex = this.lineBuffer[cr + 1] === "\n" ? cr + 2 : cr + 1;
+      return { index: cr, nextIndex };
+    }
+    return { index: lf, nextIndex: lf + 1 };
+  }
+  processLine(line) {
+    if (line === "") {
+      return this.dispatch();
+    }
+    if (line.startsWith(":")) {
+      return void 0;
+    }
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) {
+      value = value.slice(1);
+    }
+    if (field === "data") {
+      this.dataLines.push(value);
+    }
+    return void 0;
+  }
+  dispatch() {
+    if (this.dataLines.length === 0) {
+      return void 0;
+    }
+    const payload = this.dataLines.join("\n");
+    this.dataLines = [];
+    return payload.length > 0 ? payload : void 0;
+  }
+};
+
+// src/core/parse-sse.ts
+function parseSSE(source) {
+  return parseSSEGenerator(source);
+}
+async function* parseSSEGenerator(source) {
+  const parser = new SSEParser();
+  for await (const chunk of sourceToStrings(source)) {
+    for (const payload of parser.push(chunk)) {
+      yield payload;
+    }
+  }
+  for (const payload of parser.flush()) {
+    yield payload;
+  }
+}
+
+// src/core/assemble-stream.ts
+function assembleStream(source, adapter, options) {
+  return assembleFromPayloads(parseSSE(source), adapter, options);
+}
+
+// src/core/assemble-response.ts
+function assembleResponse(body, adapter, options = {}) {
+  if (!adapter.parseResponse) {
+    throw prefixedError("adapter.parseResponse is required for assembleResponse");
+  }
+  const assembler = new EventAssembler(options);
+  const events = [];
+  for (const chunk of adapter.parseResponse(body)) {
+    events.push(...assembler.push(chunk));
+  }
+  events.push(...assembler.flush(assembler.hasFinished() ? void 0 : { terminalReason: "stop" }));
+  return events;
+}
+
+// src/core/assemble-from-file.ts
+function assembleFromFile(path, adapter, options = {}) {
+  return assembleFromFileGenerator(path, adapter, options);
+}
+async function* assembleFromFileGenerator(path, adapter, options) {
+  const format = options.format ?? inferFormat(path);
+  const content = await readFixture(path);
+  if (format === "sse") {
+    yield* assembleStream(stringIterable(content), adapter, options);
+    return;
+  }
+  let body;
+  try {
+    body = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `llm-stream-assemble: assembleFromFile failed to parse JSON ${path}: ${message}`
+    );
+  }
+  for (const event of assembleResponse(body, adapter, options)) {
+    yield event;
+  }
+}
+function inferFormat(path) {
+  if (path.endsWith(".sse")) return "sse";
+  if (path.endsWith(".json")) return "json";
+  throw new Error(`llm-stream-assemble: assembleFromFile cannot infer format for ${path}`);
+}
+async function readFixture(path) {
+  try {
+    const { readFile } = await import('fs/promises');
+    return await readFile(path, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`llm-stream-assemble: assembleFromFile failed to read ${path}: ${message}`);
+  }
+}
+async function* stringIterable(value) {
+  yield value;
+}
+
+// src/core/create-assembly-transform.ts
+function createAssemblyTransform(adapter, options = {}) {
+  const decoder = new Utf8StreamDecoder();
+  const parser = new SSEParser();
+  const assembler = new EventAssembler(options);
+  let sawTerminalMarker = false;
+  let aborted = false;
+  const emit = (controller, events) => {
+    for (const event of events) {
+      controller.enqueue(event);
+    }
+  };
+  const handlePayload = (payload, controller) => {
+    const result = processPayload(payload, assembler, adapter, options);
+    if (result.kind === "done-marker") {
+      sawTerminalMarker = true;
+      return;
+    }
+    if (result.kind === "recoverable-error") {
+      controller.enqueue(result.event);
+      return;
+    }
+    emit(controller, result.events);
+  };
+  return new TransformStream({
+    start(controller) {
+      options.signal?.addEventListener(
+        "abort",
+        () => {
+          if (aborted || assembler.hasFinished()) return;
+          aborted = true;
+          emit(controller, assembler.flush({ terminalReason: "aborted" }));
+          controller.terminate();
+        },
+        { once: true }
+      );
+    },
+    transform(chunk, controller) {
+      if (aborted || options.signal?.aborted) {
+        aborted = true;
+        emit(controller, assembler.flush({ terminalReason: "aborted" }));
+        controller.terminate();
+        return;
+      }
+      for (const payload of parser.push(decoder.decode(chunk))) {
+        handlePayload(payload, controller);
+      }
+    },
+    flush(controller) {
+      if (aborted || options.signal?.aborted) {
+        emit(controller, assembler.flush({ terminalReason: "aborted" }));
+        return;
+      }
+      const decoded = decoder.flush();
+      if (decoded.length > 0) {
+        for (const payload of parser.push(decoded)) {
+          handlePayload(payload, controller);
+        }
+      }
+      for (const payload of parser.flush()) {
+        handlePayload(payload, controller);
+      }
+      emit(controller, resolveTerminalFlush(assembler, { sawTerminalMarker, aborted: false }));
+    }
+  });
+}
+
+// src/adapters/errors.ts
+function libraryError(message) {
+  return new Error(`llm-stream-assemble: ${message}`);
+}
+function adapterScopedError(scope, message) {
+  return new Error(`llm-stream-assemble: ${scope}: ${message}`);
+}
+function providerErrorChunks(error, recoverable = false) {
+  return [
+    { kind: "provider-error", error, recoverable },
+    { kind: "finish", reason: "error" }
+  ];
+}
+function providerErrorChunksFromMessage(message, recoverable = false) {
+  return providerErrorChunks(libraryError(message), recoverable);
+}
+function providerErrorChunksFromPayload(errorPayload, scope, recoverable, fallbackMessage) {
+  const message = asString(errorPayload.message) ?? fallbackMessage;
+  const error = adapterScopedError(scope, message);
+  Object.defineProperty(error, "raw", {
+    value: errorPayload,
+    enumerable: false
+  });
+  return providerErrorChunks(error, recoverable);
+}
+
+// src/adapters/utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalRawChunk(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+function prefixedAdapterError(feature, message) {
+  return adapterScopedError(feature, message);
+}
+function createStreamAdapter(config) {
+  return {
+    parseChunk(raw) {
+      return config.parser.parseChunk(raw);
+    },
+    parseResponse(body) {
+      return config.parseResponse(body, config.options);
+    }
+  };
+}
+function parseAdapterJSON(raw, feature) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw prefixedAdapterError(feature, message);
+  }
+}
+
+// src/adapters/openai-chat/parser/errors.ts
+function providerErrorPayload(payload, options) {
+  if (isRecord(payload.error)) return payload.error;
+  if (!options.looseErrorShape) return void 0;
+  const errorString = asString(payload.error);
+  if (errorString) return { message: errorString };
+  const detailString = asString(payload.detail);
+  if (detailString) return { message: detailString };
+  if (isRecord(payload.detail)) return payload.detail;
+  const topLevelMessage = asString(payload.message);
+  const topLevelType = asString(payload.type);
+  if (topLevelMessage && topLevelType === "error") return { message: topLevelMessage };
+  return void 0;
+}
+function openAIProviderErrorChunks(errorPayload, recoverable, options) {
+  return providerErrorChunksFromPayload(
+    errorPayload,
+    options.errorPrefix,
+    recoverable,
+    "OpenAI-compatible provider error"
+  );
+}
+function throwAdapterObjectError(scope, message = "expected a JSON object") {
+  throw adapterScopedError(scope, message);
+}
+function throwUnrecognizedChunkError(options) {
+  throw adapterScopedError(
+    `${options.errorPrefix}.parseChunk`,
+    "expected an OpenAI-compatible chat completion chunk"
+  );
+}
+function throwUnrecognizedResponseError(options) {
+  throw adapterScopedError(
+    `${options.errorPrefix}.parseResponse`,
+    "expected an OpenAI-compatible chat completion object"
+  );
+}
+
+// src/adapters/openai-chat/parser/chunks.ts
+function metadataChunks(payload) {
+  const chunks = [];
+  const id = asString(payload.id);
+  if (id) chunks.push({ kind: "message-start", id });
+  const metadata = { kind: "metadata", raw: payload };
+  const model = asString(payload.model);
+  const created = asNumber(payload.created);
+  if (model) metadata.model = model;
+  if (id) metadata.responseId = id;
+  if (created !== void 0) metadata.created = created;
+  if (metadata.model || metadata.responseId || metadata.created !== void 0) {
+    chunks.push(metadata);
+  }
+  return chunks;
+}
+function hasMetadata(payload) {
+  return asString(payload.id) !== void 0 || asString(payload.model) !== void 0 || asNumber(payload.created) !== void 0;
+}
+function isRecognizableResponse(payload) {
+  return hasMetadata(payload) || typeof payload.object === "string" || Array.isArray(payload.choices) || isRecord(payload.usage);
+}
+function reasoningChunks(source, options) {
+  const chunks = [];
+  const aliases = /* @__PURE__ */ new Set([
+    "reasoning",
+    "reasoning_content",
+    "reasoning_summary",
+    ...options.reasoningFieldAliases
+  ]);
+  for (const field of aliases) {
+    const text = asString(source[field]);
+    if (!text) continue;
+    chunks.push({
+      kind: "reasoning-delta",
+      text,
+      variant: field === "reasoning_summary" ? "summary" : "detail"
+    });
+  }
+  return chunks;
+}
+function finishReasonChunks(value, choiceIndex, options) {
+  if (value === null || value === void 0) return [];
+  const finishReason2 = normalizeFinishReason(value);
+  if (finishReason2) {
+    return [withChoiceIndex({ kind: "finish", reason: finishReason2 }, choiceIndex)];
+  }
+  return [
+    {
+      kind: "provider-error",
+      error: adapterScopedError(
+        options.errorPrefix,
+        `unknown OpenAI-compatible finish_reason: ${String(value)}`
+      ),
+      recoverable: true
+    },
+    withChoiceIndex({ kind: "finish", reason: "error" }, choiceIndex)
+  ];
+}
+function usageChunk(value, options) {
+  if (!isRecord(value)) return void 0;
+  const inputTokens = firstNumber(value, options.usageInputTokenFields);
+  const outputTokens = firstNumber(value, options.usageOutputTokenFields);
+  const details = isRecord(value.completion_tokens_details) ? value.completion_tokens_details : void 0;
+  const reasoningTokens = details ? asNumber(details.reasoning_tokens) : void 0;
+  if (inputTokens === void 0 && outputTokens === void 0 && reasoningTokens === void 0) {
+    return void 0;
+  }
+  const chunk = { kind: "usage", raw: value };
+  if (inputTokens !== void 0) chunk.inputTokens = inputTokens;
+  if (outputTokens !== void 0) chunk.outputTokens = outputTokens;
+  if (reasoningTokens !== void 0) chunk.reasoningTokens = reasoningTokens;
+  return chunk;
+}
+function choiceIndexFor(choice, position, options) {
+  return asNumber(choice.index) ?? (options.useChoicePositionFallback ? position : void 0);
+}
+function toolStartChunk(input) {
+  return optionalRawChunk({
+    kind: "tool-start",
+    id: input.id,
+    name: input.name,
+    index: input.index,
+    choiceIndex: input.choiceIndex
+  });
+}
+function toolArgsChunk(input) {
+  return optionalRawChunk({
+    kind: "tool-args-delta",
+    id: input.id,
+    delta: input.delta,
+    index: input.index,
+    choiceIndex: input.choiceIndex
+  });
+}
+function toolDoneChunk(input) {
+  return optionalRawChunk({
+    kind: "tool-done",
+    id: input.id,
+    index: input.index,
+    choiceIndex: input.choiceIndex
+  });
+}
+function withChoiceIndex(chunk, choiceIndex) {
+  if (choiceIndex === void 0) return chunk;
+  return optionalRawChunk({ ...chunk, choiceIndex });
+}
+function toolKey(choiceIndex, choicePosition, toolIndex) {
+  return `${choiceKey(choiceIndex, choicePosition)}:${toolIndex}`;
+}
+function choiceKey(choiceIndex, choicePosition) {
+  return choiceIndex === void 0 ? `unknown-choice:${choicePosition}` : String(choiceIndex);
+}
+function normalizeFinishReason(value) {
+  if (value === "stop" || value === "length" || value === "content_filter" || value === "tool_calls") {
+    return value;
+  }
+  if (value === "function_call") return "tool_calls";
+  return void 0;
+}
+function firstNumber(source, fields) {
+  for (const field of fields) {
+    const value = asNumber(source[field]);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+
+// src/adapters/openai-chat/parser/stream-parser.ts
+var OpenAIChatLikeParser = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  metadataEmitted = false;
+  tools = /* @__PURE__ */ new Map();
+  legacyStarted = /* @__PURE__ */ new Set();
+  parseChunk(raw) {
+    if (raw.trim() === "[DONE]") return [];
+    const payload = parseAdapterJSON(raw, `${this.options.errorPrefix}.parseChunk`);
+    if (!isRecord(payload)) {
+      throwAdapterObjectError(`${this.options.errorPrefix}.parseChunk`);
+    }
+    const looseError = providerErrorPayload(payload, this.options);
+    if (looseError) return openAIProviderErrorChunks(looseError, false, this.options);
+    if (this.options.rejectUnrecognizedPayloads && !this.isRecognizableChunk(payload)) {
+      throwUnrecognizedChunkError(this.options);
+    }
+    const chunks = [];
+    if (!this.metadataEmitted && hasMetadata(payload)) {
+      chunks.push(...metadataChunks(payload));
+      this.metadataEmitted = true;
+    }
+    const usage = usageChunk(payload.usage, this.options);
+    if (usage) chunks.push(usage);
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    for (let position = 0; position < choices.length; position += 1) {
+      const choice = choices[position];
+      if (!isRecord(choice)) continue;
+      chunks.push(...this.choiceChunks(choice, position));
+    }
+    return chunks;
+  }
+  isRecognizableChunk(payload) {
+    return hasMetadata(payload) || typeof payload.object === "string" || Array.isArray(payload.choices) || isRecord(payload.usage);
+  }
+  choiceChunks(choice, position) {
+    const choiceIndex = choiceIndexFor(choice, position, this.options);
+    const chunks = [];
+    const delta = isRecord(choice.delta) ? choice.delta : void 0;
+    if (delta) {
+      chunks.push(...this.deltaChunks(delta, choiceIndex, position));
+    }
+    chunks.push(...finishReasonChunks(choice.finish_reason, choiceIndex, this.options));
+    return chunks;
+  }
+  deltaChunks(delta, choiceIndex, choicePosition) {
+    const chunks = [];
+    const content = asString(delta.content);
+    if (content && content.length > 0) {
+      chunks.push(
+        this.options.jsonMode ? { kind: "json-delta", delta: content } : withChoiceIndex({ kind: "text-delta", text: content }, choiceIndex)
+      );
+    }
+    const refusal = asString(delta.refusal);
+    if (refusal && refusal.length > 0) {
+      chunks.push({ kind: "refusal-delta", text: refusal });
+    }
+    chunks.push(...reasoningChunks(delta, this.options));
+    chunks.push(...this.toolCallChunks(delta.tool_calls, choiceIndex, choicePosition));
+    chunks.push(...this.legacyFunctionChunks(delta.function_call, choiceIndex, choicePosition));
+    return chunks;
+  }
+  toolCallChunks(value, choiceIndex, choicePosition) {
+    if (!Array.isArray(value)) return [];
+    const chunks = [];
+    for (let position = 0; position < value.length; position += 1) {
+      const toolCall = value[position];
+      if (!isRecord(toolCall)) continue;
+      const toolIndex = asNumber(toolCall.index) ?? position;
+      const key = toolKey(choiceIndex, choicePosition, toolIndex);
+      const state = this.toolState(key);
+      const id = asString(toolCall.id);
+      const fn = isRecord(toolCall.function) ? toolCall.function : void 0;
+      const name = asString(fn?.name);
+      const args = asString(fn?.arguments);
+      if (id) state.id = id;
+      if (name) state.name = name;
+      if (!state.startEmitted && (id || name || args && args.length > 0)) {
+        chunks.push(
+          toolStartChunk({
+            id: state.id,
+            name: state.name,
+            index: toolIndex,
+            choiceIndex
+          })
+        );
+        state.startEmitted = true;
+      }
+      if (args && args.length > 0) {
+        state.sawArguments = true;
+        chunks.push(
+          toolArgsChunk({
+            id: state.id,
+            delta: args,
+            index: toolIndex,
+            choiceIndex
+          })
+        );
+      }
+    }
+    return chunks;
+  }
+  legacyFunctionChunks(value, choiceIndex, choicePosition) {
+    if (!isRecord(value)) return [];
+    const chunks = [];
+    const name = asString(value.name);
+    const args = asString(value.arguments);
+    const legacyKey = choiceKey(choiceIndex, choicePosition);
+    const id = `${this.options.legacyFunctionIdPrefix}:${choiceIndex ?? choicePosition}`;
+    if (name && !this.legacyStarted.has(legacyKey)) {
+      chunks.push(withChoiceIndex({ kind: "tool-start", id, name, index: 0 }, choiceIndex));
+      this.legacyStarted.add(legacyKey);
+    }
+    if (args && args.length > 0) {
+      if (!this.legacyStarted.has(legacyKey)) {
+        chunks.push(
+          withChoiceIndex(
+            { kind: "tool-start", id, name: name ?? "unknown", index: 0 },
+            choiceIndex
+          )
+        );
+        this.legacyStarted.add(legacyKey);
+      }
+      chunks.push(
+        withChoiceIndex({ kind: "tool-args-delta", id, delta: args, index: 0 }, choiceIndex)
+      );
+    }
+    return chunks;
+  }
+  toolState(key) {
+    let state = this.tools.get(key);
+    if (!state) {
+      state = { name: "unknown", startEmitted: false, sawArguments: false };
+      this.tools.set(key, state);
+    }
+    return state;
+  }
+};
+
+// src/adapters/openai-chat/parser/response.ts
+function parseResponse(body, options) {
+  if (!isRecord(body)) {
+    throwAdapterObjectError(
+      `${options.errorPrefix}.parseResponse`,
+      "expected an OpenAI-compatible chat completion object"
+    );
+  }
+  const looseError = providerErrorPayload(body, options);
+  if (looseError) return openAIProviderErrorChunks(looseError, false, options);
+  if (options.rejectUnrecognizedPayloads && !isRecognizableResponse(body)) {
+    throwUnrecognizedResponseError(options);
+  }
+  const chunks = [];
+  const finishChunks = [];
+  chunks.push(...metadataChunks(body));
+  const choices = Array.isArray(body.choices) ? body.choices : [];
+  for (let position = 0; position < choices.length; position += 1) {
+    const choice = choices[position];
+    if (!isRecord(choice)) continue;
+    chunks.push(...responseChoiceChunks(choice, position, options));
+    finishChunks.push(...responseChoiceFinishChunks(choice, position, options));
+  }
+  const usage = usageChunk(body.usage, options);
+  if (usage) chunks.push(usage);
+  chunks.push(...finishChunks);
+  return chunks;
+}
+function responseChoiceChunks(choice, position, options) {
+  const choiceIndex = choiceIndexFor(choice, position, options);
+  const message = isRecord(choice.message) ? choice.message : void 0;
+  const chunks = [];
+  if (message) {
+    const content = asString(message.content);
+    if (content && content.length > 0) {
+      chunks.push(
+        options.jsonMode ? { kind: "json-delta", delta: content } : withChoiceIndex({ kind: "text-delta", text: content }, choiceIndex)
+      );
+    }
+    const refusal = asString(message.refusal);
+    if (refusal && refusal.length > 0) {
+      chunks.push({ kind: "refusal-delta", text: refusal });
+    }
+    chunks.push(...reasoningChunks(message, options));
+    chunks.push(...responseToolCallChunks(message.tool_calls, choiceIndex));
+    chunks.push(
+      ...responseLegacyFunctionChunks(message.function_call, choiceIndex, position, options)
+    );
+  }
+  return chunks;
+}
+function responseChoiceFinishChunks(choice, position, options) {
+  const choiceIndex = choiceIndexFor(choice, position, options);
+  return finishReasonChunks(choice.finish_reason, choiceIndex, options);
+}
+function responseToolCallChunks(value, choiceIndex) {
+  if (!Array.isArray(value)) return [];
+  const chunks = [];
+  for (let position = 0; position < value.length; position += 1) {
+    const toolCall = value[position];
+    if (!isRecord(toolCall)) continue;
+    const fn = isRecord(toolCall.function) ? toolCall.function : void 0;
+    const id = asString(toolCall.id);
+    const name = asString(fn?.name) ?? "unknown";
+    const args = asString(fn?.arguments) ?? "";
+    const index = asNumber(toolCall.index) ?? position;
+    chunks.push(toolStartChunk({ id, name, index, choiceIndex }));
+    if (args.length > 0) chunks.push(toolArgsChunk({ id, delta: args, index, choiceIndex }));
+    chunks.push(toolDoneChunk({ id, index, choiceIndex }));
+  }
+  return chunks;
+}
+function responseLegacyFunctionChunks(value, choiceIndex, choicePosition, options) {
+  if (!isRecord(value)) return [];
+  const name = asString(value.name) ?? "unknown";
+  const args = asString(value.arguments) ?? "";
+  const id = `${options.legacyFunctionIdPrefix}:${choiceIndex ?? choicePosition}`;
+  const chunks = [
+    withChoiceIndex({ kind: "tool-start", id, name, index: 0 }, choiceIndex)
+  ];
+  if (args.length > 0) {
+    chunks.push(
+      withChoiceIndex({ kind: "tool-args-delta", id, delta: args, index: 0 }, choiceIndex)
+    );
+  }
+  chunks.push(withChoiceIndex({ kind: "tool-done", id, index: 0 }, choiceIndex));
+  return chunks;
+}
+
+// src/adapters/openai-chat/parser/types.ts
+function normalizeOptions(options) {
+  return {
+    jsonMode: options.jsonMode ?? false,
+    legacyFunctionIdPrefix: options.legacyFunctionIdPrefix ?? "legacy_function",
+    errorPrefix: options.errorPrefix,
+    looseErrorShape: options.looseErrorShape ?? false,
+    allowMissingMetadata: options.allowMissingMetadata ?? false,
+    useChoicePositionFallback: options.useChoicePositionFallback ?? true,
+    reasoningFieldAliases: options.reasoningFieldAliases ?? [],
+    usageInputTokenFields: options.usageInputTokenFields ?? ["prompt_tokens"],
+    usageOutputTokenFields: options.usageOutputTokenFields ?? ["completion_tokens"],
+    rejectUnrecognizedPayloads: options.rejectUnrecognizedPayloads ?? false
+  };
+}
+
+// src/adapters/openai-chat/parser/index.ts
+function createOpenAIChatLikeAdapter(options) {
+  const normalized = normalizeOptions(options);
+  const parser = new OpenAIChatLikeParser(normalized);
+  return createStreamAdapter({
+    parser,
+    parseResponse,
+    options: normalized
+  });
+}
+
+// src/adapters/openai-chat.ts
+function openaiChatAdapter(options = {}) {
+  return createOpenAIChatLikeAdapter({
+    ...options,
+    errorPrefix: "openaiChatAdapter",
+    looseErrorShape: false,
+    allowMissingMetadata: false,
+    useChoicePositionFallback: true,
+    usageInputTokenFields: ["prompt_tokens"],
+    usageOutputTokenFields: ["completion_tokens"]
+  });
+}
+
+// src/adapters/openai-compatible.ts
+var DEFAULT_PRESET = {
+  looseErrorShape: true,
+  allowMissingMetadata: true,
+  useChoicePositionFallback: true,
+  reasoningFieldAliases: ["thinking", "thinking_content"]
+};
+var PRESET_OVERRIDES = {
+  openrouter: { reasoningFieldAliases: ["reasoning"] },
+  together: { reasoningFieldAliases: ["reasoning", "reasoning_delta"] }
+};
+function openaiCompatibleAdapter(options = {}) {
+  const preset = providerPreset(options.provider ?? "generic");
+  return createOpenAIChatLikeAdapter({
+    ...preset,
+    ...options,
+    errorPrefix: "openaiCompatibleAdapter",
+    usageInputTokenFields: ["prompt_tokens", "input_tokens"],
+    usageOutputTokenFields: ["completion_tokens", "output_tokens"],
+    rejectUnrecognizedPayloads: options.allowMissingMetadata === false,
+    reasoningFieldAliases: [
+      ...preset.reasoningFieldAliases ?? [],
+      ...options.reasoningFieldAliases ?? []
+    ]
+  });
+}
+function providerPreset(provider) {
+  return {
+    ...DEFAULT_PRESET,
+    ...PRESET_OVERRIDES[provider]
+  };
+}
+
+// src/adapters/anthropic.ts
+function anthropicAdapter(options = {}) {
+  const parser = new AnthropicStreamParser(options);
+  return createStreamAdapter({
+    parser,
+    parseResponse: parseResponse2,
+    options
+  });
+}
+var AnthropicStreamParser = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  blocks = /* @__PURE__ */ new Map();
+  sawFinish = false;
+  parseChunk(raw) {
+    const payload = parseAdapterJSON(raw, "anthropicAdapter.parseChunk");
+    if (!isRecord(payload)) {
+      throw libraryError("anthropicAdapter.parseChunk expected a JSON object");
+    }
+    const type = asString(payload.type);
+    switch (type) {
+      case "ping":
+        return [];
+      case "message_start":
+        return this.messageStart(payload);
+      case "content_block_start":
+        return this.contentBlockStart(payload);
+      case "content_block_delta":
+        return this.contentBlockDelta(payload);
+      case "content_block_stop":
+        return this.contentBlockStop(payload);
+      case "message_delta":
+        return this.messageDelta(payload);
+      case "message_stop":
+        return this.messageStop();
+      case "error":
+        return providerErrorChunks2(payload.error);
+      default:
+        throw libraryError(`anthropicAdapter.parseChunk unknown event type: ${String(type)}`);
+    }
+  }
+  messageStart(payload) {
+    const message = isRecord(payload.message) ? payload.message : void 0;
+    if (!message) return [];
+    const chunks = [];
+    const id = asString(message.id);
+    const model = asString(message.model);
+    if (id) chunks.push({ kind: "message-start", id });
+    if (id || model) {
+      chunks.push(optionalRawChunk({ kind: "metadata", responseId: id, model, raw: message }));
+    }
+    const usage = usageChunk2(message.usage);
+    if (usage) chunks.push(usage);
+    return chunks;
+  }
+  contentBlockStart(payload) {
+    const index = asNumber(payload.index) ?? 0;
+    const block = isRecord(payload.content_block) ? payload.content_block : void 0;
+    if (!block) return [];
+    const blockType = asString(block.type) ?? "unknown";
+    const state = { type: blockType };
+    this.blocks.set(index, state);
+    switch (blockType) {
+      case "text": {
+        const text = asString(block.text);
+        return text ? [{ kind: "text-delta", text }] : [];
+      }
+      case "thinking": {
+        const text = asString(block.thinking);
+        return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
+      }
+      case "redacted_thinking":
+        return [];
+      case "tool_use": {
+        const id = asString(block.id);
+        const name = asString(block.name) ?? "unknown";
+        if (id) state.id = id;
+        state.name = name;
+        const chunks = [optionalRawChunk({ kind: "tool-start", id, name, index })];
+        const input = block.input;
+        if (input !== void 0 && !(isRecord(input) && Object.keys(input).length === 0)) {
+          chunks.push(
+            optionalRawChunk({ kind: "tool-args-delta", id, delta: JSON.stringify(input), index })
+          );
+        }
+        return chunks;
+      }
+      case "json": {
+        const text = asString(block.text) ?? asString(block.partial_json);
+        return text ? [{ kind: "json-delta", delta: text }] : [];
+      }
+      case "refusal": {
+        const text = asString(block.refusal) ?? asString(block.text);
+        return text ? [{ kind: "refusal-delta", text }] : [];
+      }
+      default:
+        return [];
+    }
+  }
+  contentBlockDelta(payload) {
+    const index = asNumber(payload.index) ?? 0;
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    if (!delta) return [];
+    const deltaType = asString(delta.type);
+    const state = this.blocks.get(index);
+    switch (deltaType) {
+      case "text_delta": {
+        const text = asString(delta.text);
+        if (!text) return [];
+        if (this.options.jsonMode || state?.type === "json")
+          return [{ kind: "json-delta", delta: text }];
+        if (state?.type === "refusal") return [{ kind: "refusal-delta", text }];
+        return [{ kind: "text-delta", text }];
+      }
+      case "thinking_delta": {
+        const text = asString(delta.thinking);
+        return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
+      }
+      case "input_json_delta": {
+        const partial = asString(delta.partial_json);
+        if (!partial) return [];
+        return [
+          optionalRawChunk({ kind: "tool-args-delta", id: state?.id, delta: partial, index })
+        ];
+      }
+      case "signature_delta":
+        return [];
+      default:
+        return [];
+    }
+  }
+  contentBlockStop(payload) {
+    const index = asNumber(payload.index) ?? 0;
+    const state = this.blocks.get(index);
+    this.blocks.delete(index);
+    if (state?.type === "tool_use") {
+      return [optionalRawChunk({ kind: "tool-done", id: state.id, index })];
+    }
+    return [];
+  }
+  messageDelta(payload) {
+    const chunks = [];
+    const usage = usageChunk2(payload.usage);
+    if (usage) chunks.push(usage);
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const stopReason = delta ? asString(delta.stop_reason) : void 0;
+    if (stopReason) {
+      const reason = finishReason(stopReason);
+      if (reason) chunks.push({ kind: "finish", reason });
+      this.sawFinish = true;
+    }
+    return chunks;
+  }
+  messageStop() {
+    if (this.sawFinish) return [];
+    this.sawFinish = true;
+    return [{ kind: "finish", reason: "stop" }];
+  }
+};
+function parseResponse2(body, options) {
+  if (!isRecord(body)) {
+    throw libraryError("anthropicAdapter.parseResponse expected an Anthropic message object");
+  }
+  if (asString(body.type) === "error" || isRecord(body.error)) {
+    return providerErrorChunks2(body.error);
+  }
+  const chunks = [];
+  const id = asString(body.id);
+  const model = asString(body.model);
+  if (id) chunks.push({ kind: "message-start", id });
+  if (id || model)
+    chunks.push(optionalRawChunk({ kind: "metadata", responseId: id, model, raw: body }));
+  const inputUsage = usageChunk2(body.usage);
+  if (inputUsage) chunks.push(inputUsage);
+  const content = Array.isArray(body.content) ? body.content : [];
+  for (let index = 0; index < content.length; index += 1) {
+    const block = content[index];
+    if (!isRecord(block)) continue;
+    chunks.push(...responseBlockChunks(block, index, options));
+  }
+  const reason = finishReason(asString(body.stop_reason));
+  if (reason) chunks.push({ kind: "finish", reason });
+  return chunks;
+}
+function responseBlockChunks(block, index, options) {
+  const type = asString(block.type);
+  switch (type) {
+    case "text": {
+      const text = asString(block.text);
+      if (!text) return [];
+      return options.jsonMode ? [{ kind: "json-delta", delta: text }] : [{ kind: "text-delta", text }];
+    }
+    case "thinking": {
+      const text = asString(block.thinking);
+      return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
+    }
+    case "tool_use": {
+      const id = asString(block.id);
+      const name = asString(block.name) ?? "unknown";
+      const chunks = [optionalRawChunk({ kind: "tool-start", id, name, index })];
+      if (block.input !== void 0) {
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-args-delta",
+            id,
+            delta: JSON.stringify(block.input),
+            index
+          })
+        );
+      }
+      chunks.push(optionalRawChunk({ kind: "tool-done", id, index }));
+      return chunks;
+    }
+    case "refusal": {
+      const text = asString(block.refusal) ?? asString(block.text);
+      return text ? [{ kind: "refusal-delta", text }] : [];
+    }
+    default:
+      return [];
+  }
+}
+function finishReason(value) {
+  switch (value) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    case "refusal":
+      return "content_filter";
+    case void 0:
+    case null:
+      return void 0;
+    default:
+      return "stop";
+  }
+}
+function usageChunk2(value) {
+  if (!isRecord(value)) return void 0;
+  const inputTokens = asNumber(value.input_tokens);
+  const outputTokens = asNumber(value.output_tokens);
+  if (inputTokens === void 0 && outputTokens === void 0) return void 0;
+  return optionalRawChunk({ kind: "usage", inputTokens, outputTokens, raw: value });
+}
+function providerErrorChunks2(value) {
+  const message = isRecord(value) ? asString(value.message) : void 0;
+  return providerErrorChunksFromMessage(message ?? "Anthropic provider error", false);
+}
+
+// src/adapters/openai-responses.ts
+function openaiResponsesAdapter(options = {}) {
+  const parser = new ResponsesParser(options);
+  return createStreamAdapter({
+    parser,
+    parseResponse: parseResponse3,
+    options
+  });
+}
+var ResponsesParser = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  metadataEmitted = false;
+  textSeen = false;
+  tools = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  parseChunk(raw) {
+    if (raw.trim() === "[DONE]") return [];
+    const payload = parseAdapterJSON(raw, "openaiResponsesAdapter.parseChunk");
+    if (!isRecord(payload)) {
+      throw libraryError("openaiResponsesAdapter.parseChunk expected a JSON object");
+    }
+    if (isErrorPayload(payload)) return providerErrorChunks3(errorMessage(payload));
+    const chunks = [];
+    const response = isRecord(payload.response) ? payload.response : payload;
+    if (!this.metadataEmitted && isRecord(response) && hasResponseMetadata(response)) {
+      chunks.push(...metadataChunks2(response));
+      this.metadataEmitted = true;
+    }
+    const type = asString(payload.type);
+    switch (type) {
+      case "response.created":
+      case "response.in_progress":
+        break;
+      case "response.output_text.delta":
+        chunks.push(...this.textDelta(payload));
+        break;
+      case "response.output_text.done":
+        chunks.push(...this.textDone(payload));
+        break;
+      case "response.refusal.delta":
+        chunks.push(...refusalDelta(payload));
+        break;
+      case "response.refusal.done":
+        break;
+      case "response.content_part.added":
+      case "response.content_part.done":
+        chunks.push(...contentPartChunks(payload, this.options));
+        break;
+      case "response.output_item.added":
+        chunks.push(...this.outputItemAdded(payload));
+        break;
+      case "response.output_item.delta":
+        chunks.push(...this.outputItemDelta(payload));
+        break;
+      case "response.output_item.done":
+        chunks.push(...this.outputItemDone(payload));
+        break;
+      case "response.function_call_arguments.delta":
+        chunks.push(...this.functionArgsDelta(payload));
+        break;
+      case "response.function_call_arguments.done":
+        chunks.push(...this.functionArgsDone(payload));
+        break;
+      case "response.completed":
+        chunks.push(...usageFromResponse(response));
+        chunks.push({ kind: "finish", reason: "stop" });
+        break;
+      case "response.failed":
+        chunks.push(...providerErrorChunks3(errorMessage(response)));
+        break;
+      case "response.incomplete":
+        chunks.push(...usageFromResponse(response));
+        chunks.push({ kind: "finish", reason: "incomplete" });
+        break;
+      case "error":
+        chunks.push(...providerErrorChunks3(errorMessage(payload)));
+        break;
+      default:
+        chunks.push(...reasoningChunks2(payload));
+        break;
+    }
+    return chunks;
+  }
+  textDelta(payload) {
+    const text = asString(payload.delta) ?? asString(payload.text);
+    if (!text) return [];
+    this.textSeen = true;
+    return [
+      this.options.jsonMode ? { kind: "json-delta", delta: text } : { kind: "text-delta", text }
+    ];
+  }
+  textDone(payload) {
+    if (this.textSeen) return [];
+    const text = asString(payload.text) ?? asString(payload.delta);
+    if (!text) return [];
+    this.textSeen = true;
+    return [
+      this.options.jsonMode ? { kind: "json-delta", delta: text } : { kind: "text-delta", text }
+    ];
+  }
+  outputItemAdded(payload) {
+    const item = isRecord(payload.item) ? payload.item : void 0;
+    if (!item) return [];
+    if (asString(item.type) === "function_call") {
+      const state = this.toolState(payload, item);
+      const chunks = [];
+      if (!state.started) {
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-start",
+            id: state.id,
+            name: state.name,
+            index: state.index
+          })
+        );
+        state.started = true;
+      }
+      const args = asString(item.arguments);
+      if (args && state.args.length === 0) {
+        state.args += args;
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-args-delta",
+            id: state.id,
+            delta: args,
+            index: state.index
+          })
+        );
+      }
+      return chunks;
+    }
+    return messageItemChunks(item, this.options);
+  }
+  outputItemDelta(payload) {
+    const delta = isRecord(payload.delta) ? payload.delta : payload;
+    const args = asString(delta.arguments) ?? asString(delta.delta);
+    if (!args) return [];
+    const state = this.toolState(payload, delta);
+    const chunks = [];
+    if (!state.started) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-start",
+          id: state.id,
+          name: state.name,
+          index: state.index
+        })
+      );
+      state.started = true;
+    }
+    state.args += args;
+    chunks.push(
+      optionalRawChunk({ kind: "tool-args-delta", id: state.id, delta: args, index: state.index })
+    );
+    return chunks;
+  }
+  outputItemDone(payload) {
+    const item = isRecord(payload.item) ? payload.item : payload;
+    if (asString(item.type) !== "function_call") return messageItemChunks(item, this.options);
+    const state = this.toolState(payload, item);
+    if (state.done) return [];
+    state.done = true;
+    return [optionalRawChunk({ kind: "tool-done", id: state.id, index: state.index })];
+  }
+  functionArgsDelta(payload) {
+    const delta = asString(payload.delta);
+    if (!delta) return [];
+    const state = this.toolState(payload);
+    const chunks = [];
+    if (!state.started) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-start",
+          id: state.id,
+          name: state.name,
+          index: state.index
+        })
+      );
+      state.started = true;
+    }
+    state.args += delta;
+    chunks.push(
+      optionalRawChunk({ kind: "tool-args-delta", id: state.id, delta, index: state.index })
+    );
+    return chunks;
+  }
+  functionArgsDone(payload) {
+    const state = this.toolState(payload);
+    const chunks = [];
+    const finalArgs = asString(payload.arguments);
+    if (finalArgs && finalArgs !== state.args && !finalArgs.startsWith(state.args)) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-args-delta",
+          id: state.id,
+          delta: finalArgs,
+          index: state.index
+        })
+      );
+      state.args += finalArgs;
+    } else if (finalArgs && finalArgs.startsWith(state.args) && finalArgs.length > state.args.length) {
+      const missing = finalArgs.slice(state.args.length);
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-args-delta",
+          id: state.id,
+          delta: missing,
+          index: state.index
+        })
+      );
+      state.args = finalArgs;
+    }
+    if (!state.started) {
+      chunks.unshift(
+        optionalRawChunk({
+          kind: "tool-start",
+          id: state.id,
+          name: state.name,
+          index: state.index
+        })
+      );
+      state.started = true;
+    }
+    if (!state.done) {
+      chunks.push(optionalRawChunk({ kind: "tool-done", id: state.id, index: state.index }));
+      state.done = true;
+    }
+    return chunks;
+  }
+  toolState(payload, item) {
+    const id = toolId(payload, item);
+    const index = asNumber(payload.output_index);
+    const existing = this.tools.get(id);
+    if (existing) {
+      const callId2 = asString(item?.call_id) ?? asString(payload.call_id);
+      const itemId2 = asString(item?.id) ?? asString(payload.item_id);
+      if (callId2) this.aliases.set(callId2, id);
+      if (itemId2) this.aliases.set(itemId2, id);
+      return existing;
+    }
+    const state = {
+      id,
+      name: asString(item?.name) ?? "unknown",
+      index,
+      args: "",
+      started: false,
+      done: false
+    };
+    this.tools.set(id, state);
+    const callId = asString(item?.call_id) ?? asString(payload.call_id);
+    const itemId = asString(item?.id) ?? asString(payload.item_id);
+    if (callId) this.aliases.set(callId, id);
+    if (itemId) this.aliases.set(itemId, id);
+    return state;
+  }
+};
+function parseResponse3(body, options) {
+  if (!isRecord(body)) {
+    throw libraryError("openaiResponsesAdapter.parseResponse expected an OpenAI Responses object");
+  }
+  if (isErrorPayload(body) || asString(body.status) === "failed") {
+    return providerErrorChunks3(errorMessage(body));
+  }
+  const chunks = [];
+  chunks.push(...metadataChunks2(body));
+  const output = Array.isArray(body.output) ? body.output : [];
+  for (let index = 0; index < output.length; index += 1) {
+    const item = output[index];
+    if (!isRecord(item)) continue;
+    if (asString(item.type) === "function_call") {
+      const id = asString(item.call_id) ?? asString(item.id) ?? `response_tool:${index}`;
+      const name = asString(item.name) ?? "unknown";
+      chunks.push({ kind: "tool-start", id, name, index });
+      const args = asString(item.arguments);
+      if (args) chunks.push({ kind: "tool-args-delta", id, delta: args, index });
+      chunks.push({ kind: "tool-done", id, index });
+    } else {
+      chunks.push(...messageItemChunks(item, options));
+    }
+  }
+  chunks.push(...usageFromResponse(body));
+  const status = asString(body.status);
+  if (status === "incomplete") chunks.push({ kind: "finish", reason: "incomplete" });
+  else chunks.push({ kind: "finish", reason: "stop" });
+  return chunks;
+}
+function metadataChunks2(response) {
+  const id = asString(response.id);
+  const chunks = [];
+  if (id) chunks.push({ kind: "message-start", id });
+  const metadata = optionalRawChunk({
+    kind: "metadata",
+    responseId: id,
+    model: asString(response.model),
+    created: asNumber(response.created_at),
+    raw: response
+  });
+  if (metadata.kind === "metadata" && (metadata.responseId || metadata.model || metadata.created)) {
+    chunks.push(metadata);
+  }
+  return chunks;
+}
+function hasResponseMetadata(response) {
+  return asString(response.id) !== void 0 || asString(response.model) !== void 0 || asNumber(response.created_at) !== void 0;
+}
+function messageItemChunks(item, options) {
+  const chunks = [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const type = asString(part.type);
+    const text = asString(part.text) ?? asString(part.delta);
+    const refusal = asString(part.refusal);
+    if (type === "output_text" && text) chunks.push(textChunk(text, options));
+    if (type === "refusal" && (refusal || text))
+      chunks.push({ kind: "refusal-delta", text: refusal ?? text ?? "" });
+  }
+  const directText = asString(item.text);
+  if (directText) chunks.push(textChunk(directText, options));
+  chunks.push(...reasoningChunks2(item));
+  return chunks;
+}
+function contentPartChunks(payload, options) {
+  const part = isRecord(payload.part) ? payload.part : isRecord(payload.content_part) ? payload.content_part : payload;
+  return messageItemChunks({ content: [part] }, options);
+}
+function refusalDelta(payload) {
+  const text = asString(payload.delta) ?? asString(payload.refusal) ?? asString(payload.text);
+  return text ? [{ kind: "refusal-delta", text }] : [];
+}
+function reasoningChunks2(payload) {
+  const chunks = [];
+  for (const field of ["reasoning", "reasoning_text", "summary"]) {
+    const text = asString(payload[field]);
+    if (text)
+      chunks.push({
+        kind: "reasoning-delta",
+        text,
+        variant: field === "summary" ? "summary" : "detail"
+      });
+  }
+  return chunks;
+}
+function usageFromResponse(response) {
+  const usage = isRecord(response.usage) ? response.usage : void 0;
+  if (!usage) return [];
+  const inputTokens = asNumber(usage.input_tokens);
+  const outputTokens = asNumber(usage.output_tokens);
+  const details = isRecord(usage.output_tokens_details) ? usage.output_tokens_details : void 0;
+  const reasoningTokens = details ? asNumber(details.reasoning_tokens) : void 0;
+  if (inputTokens === void 0 && outputTokens === void 0 && reasoningTokens === void 0)
+    return [];
+  return [
+    optionalRawChunk({
+      kind: "usage",
+      inputTokens,
+      outputTokens,
+      reasoningTokens,
+      raw: usage
+    })
+  ];
+}
+function textChunk(text, options) {
+  return options.jsonMode ? { kind: "json-delta", delta: text } : { kind: "text-delta", text };
+}
+function providerErrorChunks3(message) {
+  return providerErrorChunksFromMessage(message, false);
+}
+function errorMessage(payload) {
+  const error = isRecord(payload.error) ? payload.error : void 0;
+  return asString(error?.message) ?? asString(payload.message) ?? asString(payload.error) ?? "OpenAI Responses provider error";
+}
+function isErrorPayload(payload) {
+  return asString(payload.type) === "error" || payload.error !== void 0;
+}
+function toolId(payload, item) {
+  const callId = asString(item?.call_id) ?? asString(payload.call_id);
+  const itemId = asString(item?.id) ?? asString(payload.item_id);
+  const index = asNumber(payload.output_index);
+  return callId ?? itemId ?? `response_tool:${index ?? 0}`;
+}
+
+// src/transforms/collect-stream.ts
+async function collectStream(events) {
+  const result = {
+    text: "",
+    reasoning: "",
+    refusals: "",
+    json: void 0,
+    toolCalls: []
+  };
+  const iterator = events[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      const item = await iterator.next();
+      if (item.done) break;
+      collectEvent(result, item.value);
+    }
+    return result;
+  } catch (error) {
+    await iterator.return?.();
+    throw error;
+  }
+}
+function collectEvent(result, event) {
+  switch (event.type) {
+    case "text.delta":
+      result.text += event.text;
+      break;
+    case "text.done":
+      result.text = preferDone(result.text, event.text);
+      break;
+    case "reasoning.delta":
+      result.reasoning += event.text;
+      break;
+    case "reasoning.done":
+      result.reasoning = preferDone(result.reasoning, event.text);
+      break;
+    case "refusal.delta":
+      result.refusals += event.text;
+      break;
+    case "refusal.done":
+      result.refusals = preferDone(result.refusals, event.text);
+      break;
+    case "json.done":
+      result.json = event.value;
+      break;
+    case "tool_call.done":
+      result.toolCalls.push({ id: event.id, name: event.name, args: event.args });
+      break;
+    case "usage":
+      result.usage = event;
+      break;
+    case "finish":
+      result.finishReason = event;
+      break;
+    case "error":
+      if (event.recoverable !== true) throw event.error;
+      break;
+  }
+}
+function preferDone(current, done) {
+  if (current === "" || current === done || done.startsWith(current)) return done;
+  if (current.endsWith(done)) return current;
+  return done;
+}
+
+// src/transforms/to-sse.ts
+function toSSE(events, options = {}) {
+  const iterator = events[Symbol.asyncIterator]();
+  const encoder2 = new TextEncoder();
+  let closed = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (closed) return;
+      try {
+        const item = await iterator.next();
+        if (item.done) {
+          closed = true;
+          controller.close();
+          return;
+        }
+        const event = item.value;
+        controller.enqueue(
+          encoder2.encode(`data: ${JSON.stringify(serializeEvent(event, options))}
+
+`)
+        );
+        if (event.type === "finish") {
+          closed = true;
+          await iterator.return?.();
+          controller.close();
+        }
+      } catch (error) {
+        closed = true;
+        await iterator.return?.();
+        controller.error(error);
+      }
+    },
+    async cancel() {
+      closed = true;
+      await iterator.return?.();
+    }
+  });
+}
+function serializeEvent(event, options) {
+  if (event.type !== "error") return event;
+  const message = options.sanitizeErrors ? event.sanitized ?? "An error occurred while processing the stream." : event.error.message;
+  return {
+    type: "error",
+    error: {
+      name: event.error.name,
+      message
+    },
+    ...event.recoverable === void 0 ? {} : { recoverable: event.recoverable },
+    ...event.sanitized === void 0 ? {} : { sanitized: event.sanitized }
+  };
+}
+
+// src/transforms/tap-events.ts
+function tapEvents(events, onEvent) {
+  return tapEventsGenerator(events, onEvent);
+}
+async function* tapEventsGenerator(events, onEvent) {
+  const iterator = events[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      const item = await iterator.next();
+      if (item.done) break;
+      onEvent(item.value);
+      yield item.value;
+    }
+  } finally {
+    await iterator.return?.();
+  }
+}
+
+// src/helpers/match-event.ts
+function matchEvent(event, handlers) {
+  switch (event.type) {
+    case "message.start":
+      return handlers["message.start"]?.(event);
+    case "metadata":
+      return handlers.metadata?.(event);
+    case "text.delta":
+      return handlers["text.delta"]?.(event);
+    case "text.done":
+      return handlers["text.done"]?.(event);
+    case "reasoning.delta":
+      return handlers["reasoning.delta"]?.(event);
+    case "reasoning.done":
+      return handlers["reasoning.done"]?.(event);
+    case "refusal.delta":
+      return handlers["refusal.delta"]?.(event);
+    case "refusal.done":
+      return handlers["refusal.done"]?.(event);
+    case "json.delta":
+      return handlers["json.delta"]?.(event);
+    case "json.done":
+      return handlers["json.done"]?.(event);
+    case "tool_call.start":
+      return handlers["tool_call.start"]?.(event);
+    case "tool_call.args.delta":
+      return handlers["tool_call.args.delta"]?.(event);
+    case "tool_call.done":
+      return handlers["tool_call.done"]?.(event);
+    case "usage":
+      return handlers.usage?.(event);
+    case "finish":
+      return handlers.finish?.(event);
+    case "error":
+      return handlers.error?.(event);
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/helpers/type-guards.ts
+function isMessageStart(event) {
+  return event.type === "message.start";
+}
+function isMetadata(event) {
+  return event.type === "metadata";
+}
+function isTextDelta(event) {
+  return event.type === "text.delta";
+}
+function isTextDone(event) {
+  return event.type === "text.done";
+}
+function isReasoningDelta(event) {
+  return event.type === "reasoning.delta";
+}
+function isReasoningDone(event) {
+  return event.type === "reasoning.done";
+}
+function isRefusalDelta(event) {
+  return event.type === "refusal.delta";
+}
+function isRefusalDone(event) {
+  return event.type === "refusal.done";
+}
+function isJsonDelta(event) {
+  return event.type === "json.delta";
+}
+function isJsonDone(event) {
+  return event.type === "json.done";
+}
+function isToolCallStart(event) {
+  return event.type === "tool_call.start";
+}
+function isToolCallArgsDelta(event) {
+  return event.type === "tool_call.args.delta";
+}
+function isToolCallDone(event) {
+  return event.type === "tool_call.done";
+}
+function isUsage(event) {
+  return event.type === "usage";
+}
+function isFinish(event) {
+  return event.type === "finish";
+}
+function isError(event) {
+  return event.type === "error";
+}
+
+exports.anthropicAdapter = anthropicAdapter;
+exports.assembleFromFile = assembleFromFile;
+exports.assembleFromPayloads = assembleFromPayloads;
+exports.assembleResponse = assembleResponse;
+exports.assembleStream = assembleStream;
+exports.collectStream = collectStream;
+exports.createAssemblyTransform = createAssemblyTransform;
+exports.isError = isError;
+exports.isFinish = isFinish;
+exports.isJsonDelta = isJsonDelta;
+exports.isJsonDone = isJsonDone;
+exports.isMessageStart = isMessageStart;
+exports.isMetadata = isMetadata;
+exports.isReasoningDelta = isReasoningDelta;
+exports.isReasoningDone = isReasoningDone;
+exports.isRefusalDelta = isRefusalDelta;
+exports.isRefusalDone = isRefusalDone;
+exports.isTextDelta = isTextDelta;
+exports.isTextDone = isTextDone;
+exports.isToolCallArgsDelta = isToolCallArgsDelta;
+exports.isToolCallDone = isToolCallDone;
+exports.isToolCallStart = isToolCallStart;
+exports.isUsage = isUsage;
+exports.matchEvent = matchEvent;
+exports.openaiChatAdapter = openaiChatAdapter;
+exports.openaiCompatibleAdapter = openaiCompatibleAdapter;
+exports.openaiResponsesAdapter = openaiResponsesAdapter;
+exports.parsePartialJSON = parsePartialJSON;
+exports.parseSSE = parseSSE;
+exports.tapEvents = tapEvents;
+exports.toSSE = toSSE;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map