@codehz/ai 0.2.4 → 0.4.0

package/src/helpers/incremental-stream-parser.ts

@@ -82,3 +82,61 @@ export function splitSSEFrames(buffer: string, allowEOF: boolean): StreamSplitRe
 
   return { items, rest: normalized.slice(cursor) };
 }
+
+// ── 常用 parse 工厂 ───────────────────────────────────────────
+
+export type SseJsonEvent = { type: string; data: unknown };
+
+/** 解析标准 SSE frame（event: + data:），用于 Messages / Responses。 */
+export function parseSseJsonFrame(frame: string): StreamParseResult<SseJsonEvent> {
+  let eventType = "";
+  let dataStr = "";
+  for (const rawLine of frame.split("\n")) {
+    const line = rawLine.trim();
+    if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+    else if (line.startsWith("data: ")) dataStr += line.slice(6);
+  }
+  if (!eventType) return { status: "ignored" };
+  try {
+    const data: unknown = JSON.parse(dataStr);
+    return { status: "parsed", value: { type: eventType, data } };
+  } catch {
+    return { status: "malformed" };
+  }
+}
+
+export function createSseJsonParser<T extends SseJsonEvent = SseJsonEvent>(): IncrementalStreamParser<T> {
+  return new IncrementalStreamParser(splitSSEFrames, (frame) => parseSseJsonFrame(frame) as StreamParseResult<T>);
+}
+
+/** OpenAI Chat Completions 简化 SSE：仅 `data: ...` 行，忽略 `[DONE]`。 */
+export function parseChatCompletionsDataLine(item: string): StreamParseResult<unknown> {
+  const trimmed = item.trim();
+  if (!trimmed.startsWith("data: ")) return { status: "ignored" };
+  const data = trimmed.slice(6).trim();
+  if (data === "[DONE]") return { status: "ignored" };
+  try {
+    return { status: "parsed", value: JSON.parse(data) as unknown };
+  } catch {
+    return { status: "malformed" };
+  }
+}
+
+export function createChatCompletionsSseParser<T>(): IncrementalStreamParser<T> {
+  return new IncrementalStreamParser(splitLines, (item) => parseChatCompletionsDataLine(item) as StreamParseResult<T>);
+}
+
+/** NDJSON 行解析（Ollama 等）：空行忽略，JSON 失败为 malformed。 */
+export function createNdjsonLineParser<T>(isValid: (value: unknown) => value is T): IncrementalStreamParser<T> {
+  return new IncrementalStreamParser<T>(splitLines, (item: string): StreamParseResult<T> => {
+    const trimmed = item.trim();
+    if (!trimmed) return { status: "ignored" };
+    try {
+      const parsed: unknown = JSON.parse(trimmed);
+      if (isValid(parsed)) return { status: "parsed", value: parsed };
+      return { status: "malformed" };
+    } catch {
+      return { status: "malformed" };
+    }
+  });
+}

package/src/helpers/index.ts

@@ -13,7 +13,6 @@ export {
   opaqueBlock,
   blockToText,
   contentBlocksToText,
-  instructionsToText,
   extractText,
   messageItem,
   reasoningItem,
@@ -23,12 +22,9 @@ export {
   replayFromOutput,
 } from "./mapping.js";
 
-export { parseSSEEvents } from "./sse-parser.js";
-export type { SSEEvent } from "./sse-parser.js";
-
 export { AdapterBase } from "./adapter-base.js";
 export type { StreamResult } from "./adapter-base.js";
-export { AdapterAuxiliaryState, emitMalformedStreamWarning, metadataSourceList } from "./adapter-auxiliary.js";
+export { AdapterAuxiliaryState, emitMalformedStreamWarning } from "./adapter-auxiliary.js";
 export type { AuxiliaryFinalizeOptions, AuxiliaryFinalizeResult, BillingPostprocessHook } from "./adapter-auxiliary.js";
 export { syntheticStream } from "./synthetic-stream.js";
 export type { SyntheticStreamOptions } from "./synthetic-stream.js";
@@ -54,8 +50,24 @@ export {
 } from "./adapter-security.js";
 export type { OpaqueEnvelopeResult } from "./adapter-security.js";
 
-export { IncrementalStreamParser, splitLines, splitSSEFrames } from "./incremental-stream-parser.js";
-export type { StreamSplitResult, StreamParseResult } from "./incremental-stream-parser.js";
+export {
+  IncrementalStreamParser,
+  splitLines,
+  splitSSEFrames,
+  parseSseJsonFrame,
+  createSseJsonParser,
+  parseChatCompletionsDataLine,
+  createChatCompletionsSseParser,
+  createNdjsonLineParser,
+} from "./incremental-stream-parser.js";
+export type { StreamSplitResult, StreamParseResult, SseJsonEvent } from "./incremental-stream-parser.js";
+
+export { openProviderJsonStream, iterateProviderStreamBatches, createCompletionGate } from "./provider-stream.js";
+export type {
+  OpenProviderJsonStreamOptions,
+  OpenedProviderStream,
+  ProviderStreamBatch,
+  ProviderStreamBatchOptions,
+} from "./provider-stream.js";
 
 export { NormalizedRequestMapper } from "./request-mapper.js";
-export type { ProviderProfile } from "./request-mapper.js";

package/src/helpers/mapping.ts

@@ -12,7 +12,6 @@
 import type {
   StopReason,
   ContentBlock,
-  InstructionBlock,
   MessageItem,
   ReasoningItem,
   ToolCallItem,
@@ -100,13 +99,12 @@ export function reasoningItem(
   };
 }
 
-export function toolCallItem(id: string, name: string, argumentsText: string, argumentsJson?: unknown): ToolCallItem {
+export function toolCallItem(id: string, name: string, argumentsText: string): ToolCallItem {
   return {
     type: "tool_call",
     id,
     name,
     argumentsText,
-    argumentsJson,
   };
 }
 
@@ -179,13 +177,6 @@ export function contentBlocksToText(blocks: ContentBlock[]): string {
   return blocks.map(blockToText).join("\n");
 }
 
-/**
- * 将 instructions（string | InstructionBlock[]）归一化为纯文本。
- */
-export function instructionsToText(instructions: string | InstructionBlock[]): string {
-  return typeof instructions === "string" ? instructions : contentBlocksToText(instructions);
-}
-
 // ── Output 文本提取 ───────────────────────────────────────────
 
 /**

package/src/helpers/provider-stream.ts

@@ -0,0 +1,147 @@
+/**
+ * Provider HTTP 流公共脚手架
+ *
+ * 收敛 adapter 间重复的：
+ * - JSON POST + 错误映射
+ * - ReadableStream reader 生命周期
+ * - IncrementalStreamParser feed/flush + malformed warning
+ * - 不完整尾帧 warning
+ */
+
+import { AIProviderError, AIStreamError } from "../core/errors.js";
+import type { EventFactory } from "../core/event-factory.js";
+import type { AIStreamEvent, FetchFn } from "../types/index.js";
+import { emitMalformedStreamWarning } from "./adapter-auxiliary.js";
+import { providerHttpError } from "./adapter-security.js";
+import type { IncrementalStreamParser } from "./incremental-stream-parser.js";
+
+export type OpenProviderJsonStreamOptions = {
+  fetchFn: FetchFn;
+  url: string;
+  headers: Record<string, string>;
+  body: unknown;
+  signal?: AbortSignal;
+};
+
+export type OpenedProviderStream = {
+  reader: ReadableStreamDefaultReader<Uint8Array>;
+  headers: Headers;
+};
+
+/** POST JSON 并返回可读 body reader + response headers；统一网络/HTTP/空 body 错误。 */
+export async function openProviderJsonStream(options: OpenProviderJsonStreamOptions): Promise<OpenedProviderStream> {
+  const { fetchFn, url, headers, body, signal } = options;
+
+  let response: Response;
+  try {
+    response = await fetchFn(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal,
+    });
+  } catch (err) {
+    throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+  }
+
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    throw providerHttpError(response.status, errorBody);
+  }
+
+  const bodyStream = response.body;
+  if (!bodyStream) {
+    throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
+  }
+
+  // Bun/DOM ReadableStreamDefaultReader 类型略有差异，按最小接口使用
+  return {
+    reader: bodyStream.getReader() as ReadableStreamDefaultReader<Uint8Array>,
+    headers: response.headers,
+  };
+}
+
+export type ProviderStreamBatchOptions<T> = {
+  reader: ReadableStreamDefaultReader<Uint8Array>;
+  parser: IncrementalStreamParser<T>;
+  factory: EventFactory;
+  providerLabel: string;
+  transportLabel: string;
+  incompleteMessage: string;
+};
+
+export type ProviderStreamBatch<T> = {
+  items: T[];
+  warnings: AIStreamEvent[];
+};
+
+/**
+ * 读取并解析 provider 流。
+ * 每个 batch 携带本轮解析出的 items 与（可选）malformed / incomplete warning。
+ * 调用方应 `for await` 消费完毕；reader 在迭代结束时 cancel/release。
+ */
+export async function* iterateProviderStreamBatches<T>(
+  options: ProviderStreamBatchOptions<T>,
+): AsyncGenerator<ProviderStreamBatch<T>, void, undefined> {
+  const { reader, parser, factory, providerLabel, transportLabel, incompleteMessage } = options;
+  let streamDone = false;
+
+  try {
+    while (true) {
+      const readResult = await reader.read().catch((err: unknown) => {
+        throw new AIStreamError(
+          `Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`,
+          "STREAM_ERROR",
+        );
+      });
+      const { done, value } = readResult;
+      const { items, malformed } = done ? parser.flush() : parser.feed(value as Uint8Array);
+
+      const warnings: AIStreamEvent[] = [];
+      const malformedWarning = emitMalformedStreamWarning(factory, {
+        count: malformed,
+        providerLabel,
+        transportLabel,
+      });
+      if (malformedWarning) warnings.push(malformedWarning);
+
+      yield { items, warnings };
+
+      if (done) {
+        streamDone = true;
+        break;
+      }
+    }
+  } finally {
+    try {
+      if (!streamDone) await reader.cancel().catch(() => undefined);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  if (parser.getRemaining().trim().length > 0) {
+    yield {
+      items: [],
+      warnings: [factory.responseWarning(incompleteMessage, "STREAM_ERROR")],
+    };
+  }
+}
+
+/** 一次性 complete 守卫：首次成功，后续返回 false。 */
+export function createCompletionGate(): {
+  readonly completed: boolean;
+  tryComplete(): boolean;
+} {
+  let completed = false;
+  return {
+    get completed() {
+      return completed;
+    },
+    tryComplete() {
+      if (completed) return false;
+      completed = true;
+      return true;
+    },
+  };
+}

package/src/helpers/request-mapper.ts

@@ -1,18 +1,10 @@
 import { AIRequestError } from "../core/errors.js";
 import { contentBlocksToText } from "./mapping.js";
 
-import type { AdapterCapabilities, ContentBlock, InstructionBlock, ToolResultItem } from "../types/index.js";
-
-export type ProviderProfile = {
-  readonly kind: string;
-  readonly instructionsMode: "system_message" | "instructions_field" | "none";
-  readonly supportedBlockTypes: ReadonlyArray<ContentBlock["type"]>;
-  readonly reasoningBlockTypes: ReadonlyArray<ContentBlock["type"]>;
-  readonly capabilities: AdapterCapabilities;
-};
+import type { ContentBlock, InstructionBlock, ToolCallItem, ToolChoice, ToolDefinition } from "../types/index.js";
 
 export class NormalizedRequestMapper {
-  constructor(readonly profile: ProviderProfile) {}
+  constructor(readonly kind: string) {}
 
   mapInstructions(instructions: string | InstructionBlock[]): string {
     return typeof instructions === "string"
@@ -21,27 +13,33 @@ export class NormalizedRequestMapper {
   }
 
   ensureTextBlocks(blocks: ContentBlock[], field: string): ContentBlock[] {
-    return this.ensureBlocks(blocks, field, this.profile.supportedBlockTypes, "only text/json blocks are supported");
+    return this.ensureBlocks(blocks, field, ["text", "json"], "only text/json blocks are supported");
   }
 
   ensureReasoningBlocks(blocks: ContentBlock[], field: string): Array<Extract<ContentBlock, { type: "text" }>> {
-    return this.ensureBlocks(
-      blocks,
-      field,
-      this.profile.reasoningBlockTypes,
-      "reasoning only supports text blocks",
-    ) as Array<Extract<ContentBlock, { type: "text" }>>;
+    return this.ensureBlocks(blocks, field, ["text"], "reasoning only supports text blocks") as Array<
+      Extract<ContentBlock, { type: "text" }>
+    >;
+  }
+
+  /** ensureTextBlocks + contentBlocksToText 的常见组合。 */
+  textFromBlocks(blocks: ContentBlock[], field: string): string {
+    return contentBlocksToText(this.ensureTextBlocks(blocks, field));
   }
 
-  assertToolResultOutcome(outcome: ToolResultItem["outcome"]): void {
-    if (this.profile.capabilities.toolResultOutcomes.includes(outcome)) return;
+  parseToolArguments(item: ToolCallItem): Record<string, unknown> {
+    try {
+      const parsed: unknown = JSON.parse(item.argumentsText);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      // handled below
+    }
 
-    const outcomes = this.profile.capabilities.toolResultOutcomes;
-    const supported = outcomes.map((value) => `"${value}"`).join(" and ");
-    const verb = outcomes.length > 1 ? "are" : "is";
     throw new AIRequestError(
-      `${this.profile.kind} does not preserve tool_result outcome "${outcome}"; only ${supported} ${verb} supported`,
-      "UNSUPPORTED_TOOL_RESULT_OUTCOME",
+      `${this.kind} requires tool_call argumentsText to be a valid JSON object`,
+      "TOOL_CALL_ARGUMENTS_INVALID",
     );
   }
 
@@ -51,6 +49,30 @@ export class NormalizedRequestMapper {
     }
   }
 
+  mapToolsIfPresent<T>(tools: ToolDefinition[] | undefined, map: (tool: ToolDefinition) => T): T[] | undefined {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map(map);
+  }
+
+  /**
+   * 将 canonical toolChoice 映射为 provider 形状。
+   * 返回 undefined 表示调用方无需写入 body 字段。
+   */
+  mapToolChoice<T>(
+    toolChoice: ToolChoice | undefined,
+    mappers: {
+      auto: T;
+      none: T;
+      tool: (name: string) => T;
+    },
+  ): T | undefined {
+    if (!toolChoice) return undefined;
+    if (toolChoice === "auto") return mappers.auto;
+    if (toolChoice === "none") return mappers.none;
+    if (toolChoice.type === "tool") return mappers.tool(toolChoice.name);
+    return undefined;
+  }
+
   private ensureBlocks(
     blocks: ContentBlock[],
     field: string,
@@ -61,7 +83,7 @@ export class NormalizedRequestMapper {
       const block = blocks[i];
       if (block && !supportedTypes.includes(block.type)) {
         throw new AIRequestError(
-          `${this.profile.kind} does not support ${field}[${i}] of type "${block.type}"; ${description}`,
+          `${this.kind} does not support ${field}[${i}] of type "${block.type}"; ${description}`,
           "UNSUPPORTED_CONTENT_BLOCK",
         );
       }

package/src/helpers/usage-mapping.ts

@@ -20,6 +20,26 @@ function record(obj: Record<string, number | undefined>): Partial<Usage> {
   return out;
 }
 
+function withDerivedTotal(usage: {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  cachedInputTokens?: number;
+  reasoningTokens?: number;
+  cacheWriteInputTokens?: number;
+}): Partial<Usage> {
+  const { inputTokens, outputTokens, totalTokens, cachedInputTokens, reasoningTokens, cacheWriteInputTokens } = usage;
+  return record({
+    inputTokens,
+    outputTokens,
+    totalTokens:
+      totalTokens ?? (inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined),
+    cachedInputTokens,
+    reasoningTokens,
+    cacheWriteInputTokens,
+  });
+}
+
 /** OpenAI Chat Completions `usage` */
 export function usageFromChatCompletions(raw: {
   prompt_tokens?: number;
@@ -28,20 +48,12 @@ export function usageFromChatCompletions(raw: {
   prompt_tokens_details?: { cached_tokens?: number; [key: string]: unknown };
   completion_tokens_details?: { reasoning_tokens?: number; [key: string]: unknown };
 }): Partial<Usage> {
-  const inputTokens = num(raw.prompt_tokens);
-  const outputTokens = num(raw.completion_tokens);
-  const cachedInputTokens = num(raw.prompt_tokens_details?.cached_tokens);
-  const reasoningTokens = num(raw.completion_tokens_details?.reasoning_tokens);
-  const totalTokens =
-    num(raw.total_tokens) ??
-    (inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined);
-
-  return record({
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    cachedInputTokens,
-    reasoningTokens,
+  return withDerivedTotal({
+    inputTokens: num(raw.prompt_tokens),
+    outputTokens: num(raw.completion_tokens),
+    totalTokens: num(raw.total_tokens),
+    cachedInputTokens: num(raw.prompt_tokens_details?.cached_tokens),
+    reasoningTokens: num(raw.completion_tokens_details?.reasoning_tokens),
   });
 }
 
@@ -54,20 +66,12 @@ export function usageFromOpenAIResponses(raw: {
   output_tokens_details?: { reasoning_tokens?: number; [key: string]: unknown };
   [key: string]: unknown;
 }): Partial<Usage> {
-  const inputTokens = num(raw.input_tokens);
-  const outputTokens = num(raw.output_tokens);
-  const cachedInputTokens = num(raw.input_tokens_details?.cached_tokens);
-  const reasoningTokens = num(raw.output_tokens_details?.reasoning_tokens);
-  const totalTokens =
-    num(raw.total_tokens) ??
-    (inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined);
-
-  return record({
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    cachedInputTokens,
-    reasoningTokens,
+  return withDerivedTotal({
+    inputTokens: num(raw.input_tokens),
+    outputTokens: num(raw.output_tokens),
+    totalTokens: num(raw.total_tokens),
+    cachedInputTokens: num(raw.input_tokens_details?.cached_tokens),
+    reasoningTokens: num(raw.output_tokens_details?.reasoning_tokens),
   });
 }
 
@@ -88,12 +92,10 @@ export function usageFromAnthropicMessages(raw: {
     (n): n is number => n !== undefined,
   );
   const inputTokens = inputParts.length > 0 ? inputParts.reduce((sum, n) => sum + n, 0) : undefined;
-  const totalTokens = inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
 
-  return record({
+  return withDerivedTotal({
     inputTokens,
     outputTokens,
-    totalTokens,
     cachedInputTokens,
     cacheWriteInputTokens,
   });
@@ -101,13 +103,8 @@ export function usageFromAnthropicMessages(raw: {
 
 /** Ollama 流式 chunk */
 export function usageFromOllama(raw: { prompt_eval_count?: number; eval_count?: number }): Partial<Usage> {
-  const inputTokens = num(raw.prompt_eval_count);
-  const outputTokens = num(raw.eval_count);
-  const totalTokens = inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined;
-
-  return record({
-    inputTokens,
-    outputTokens,
-    totalTokens,
+  return withDerivedTotal({
+    inputTokens: num(raw.prompt_eval_count),
+    outputTokens: num(raw.eval_count),
   });
 }

package/src/types/adapter.ts

@@ -21,20 +21,9 @@ export type NormalizedRequest = AIRequest & {
 
 // ── Adapter 接口 ──────────────────────────────────────────────
 
-export type StreamingCapability = "native" | "synthetic" | "none";
-
-export type AdapterCapabilities = {
-  readonly textStreaming: StreamingCapability;
-  readonly reasoningStreaming: StreamingCapability;
-  readonly toolCallStreaming: StreamingCapability;
-  readonly replay: "canonical" | "opaque" | "none";
-  readonly usage: "stream" | "final" | "none";
-  readonly toolResultOutcomes: ReadonlyArray<"success" | "error" | "rejected">;
-};
-
 export interface BackendAdapter {
   readonly kind: "chat-completions" | "messages" | "responses" | "ollama" | "mock";
-  readonly capabilities: AdapterCapabilities;
+  readonly isSyntheticStream: boolean;
   stream(request: NormalizedRequest): AsyncIterable<AIStreamEvent>;
 }
 

package/src/types/index.ts

@@ -46,12 +46,4 @@ export type {
 } from "./events.js";
 
 // Adapter 协议和 client 类型
-export type {
-  AdapterCapabilities,
-  StreamingCapability,
-  BackendAdapter,
-  FetchFn,
-  NormalizedRequest,
-  CreateAIClientOptions,
-  AIClient,
-} from "./adapter.js";
+export type { BackendAdapter, FetchFn, NormalizedRequest, CreateAIClientOptions, AIClient } from "./adapter.js";

package/src/types/items.ts

@@ -27,7 +27,6 @@ export type ToolCallItem = {
   id: string;
   name: string;
   argumentsText: string;
-  argumentsJson?: unknown;
 };
 
 export type ToolResultItem = {

package/src/helpers/sse-parser.ts

@@ -1,113 +0,0 @@
-/**
- * 通用 SSE (Server-Sent Events) 解析器
- *
- * 解析标准 SSE 格式（event: + data: 行），适用于：
- * - Anthropic Messages API (messages.ts)
- * - OpenAI Responses API (responses.ts)
- *
- * 注意：OpenAI Chat Completions API 使用简化 SSE（仅有 data: 行），
- * 由 chat-completions.ts 中的 parseChatSSE 处理。
- *
- * 用法：
- * ```ts
- * const { events, rest } = parseSSEEvents(buffer);
- * for (const ev of events) {
- *   // ev.type — 事件类型字符串
- *   // ev.data — 已解析的 JSON 数据
- * }
- * // rest 是未处理的剩余 buffer，需要累积到下次调用
- * ```
- */
-
-export type SSEEvent = { type: string; data: unknown };
-
-export type SSEParseResult = {
-  events: SSEEvent[];
-  rest: string;
-  malformedEvents: number;
-};
-
-export type ParseSSEOptions = {
-  allowEOF?: boolean;
-};
-
-/**
- * 将 SSE 文本块解析为事件数组。
- * 累积事件行直到遇到空行，支持 [DONE] 标记。
- * 返回已解析的事件和未处理的剩余 buffer（用于增量解析）。
- *
- * 关键行为：
- * - 只解析完整的 event（以空行结尾）
- * - 未完成的行保留在 rest 中，等待下次 chunk 补全
- * - 支持跨 chunk 的 event 分片
- */
-export function parseSSEEvents(chunk: string, options: ParseSSEOptions = {}): SSEParseResult {
-  const events: SSEEvent[] = [];
-  let eventType = "";
-  let dataLines: string[] = [];
-  let consumedUntil = 0;
-  let cursor = 0;
-  let malformedEvents = 0;
-
-  const emitEvent = (consumedCursor: number): void => {
-    const dataStr = dataLines.join("\n");
-    if (dataStr === "[DONE]") {
-      eventType = "";
-      dataLines = [];
-      consumedUntil = consumedCursor;
-      return;
-    }
-
-    try {
-      const data = JSON.parse(dataStr);
-      events.push({ type: eventType, data });
-    } catch {
-      malformedEvents++;
-    }
-
-    eventType = "";
-    dataLines = [];
-    consumedUntil = consumedCursor;
-  };
-
-  const consumeLine = (line: string, consumedCursor: number): void => {
-    if (line.startsWith("event: ")) {
-      eventType = line.slice(7).trim();
-    } else if (line.startsWith("data: ")) {
-      dataLines.push(line.slice(6));
-    } else if (line === "" && eventType && dataLines.length > 0) {
-      emitEvent(consumedCursor);
-    } else if (line === "" && !eventType && dataLines.length === 0) {
-      consumedUntil = consumedCursor;
-    }
-  };
-
-  while (cursor < chunk.length) {
-    const lineEnd = chunk.indexOf("\n", cursor);
-    if (lineEnd === -1) break;
-
-    let line = chunk.slice(cursor, lineEnd);
-    cursor = lineEnd + 1;
-
-    if (line.endsWith("\r")) {
-      line = line.slice(0, -1);
-    }
-
-    consumeLine(line, cursor);
-  }
-
-  if (options.allowEOF && cursor < chunk.length) {
-    let line = chunk.slice(cursor);
-    if (line.endsWith("\r")) {
-      line = line.slice(0, -1);
-    }
-    consumeLine(line, chunk.length);
-    cursor = chunk.length;
-  }
-
-  if (options.allowEOF && eventType && dataLines.length > 0) {
-    emitEvent(chunk.length);
-  }
-
-  return { events, rest: chunk.slice(consumedUntil), malformedEvents };
-}