llm-stream-assemble 1.0.0

package/dist/core/index.cjs

@@ -0,0 +1,816 @@
+'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 }));
+    }
+  });
+}
+
+exports.assembleFromFile = assembleFromFile;
+exports.assembleFromPayloads = assembleFromPayloads;
+exports.assembleResponse = assembleResponse;
+exports.assembleStream = assembleStream;
+exports.createAssemblyTransform = createAssemblyTransform;
+exports.parsePartialJSON = parsePartialJSON;
+exports.parseSSE = parseSSE;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map