@omnicross/core 0.1.0 → 0.1.2

package/dist/sse-parser.cjs

@@ -1,456 +1,8 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/sse-parser.ts
-var sse_parser_exports = {};
-__export(sse_parser_exports, {
-  createSSEParser: () => createSSEParser,
-  streamSSEResponse: () => streamSSEResponse
-});
-module.exports = __toCommonJS(sse_parser_exports);
-var DEBUG_SSE = true;
-function debugSSE(prefix, ...args) {
-  if (DEBUG_SSE) {
-    console.log(`[SSE-Parser] ${prefix}`, ...args);
-  }
-}
-function createSSEParser(format, callbacks) {
-  const state = {
-    buffer: "",
-    content: "",
-    reasoning: "",
-    usage: void 0,
-    isDone: false,
-    streamStartTime: void 0,
-    firstTokenTime: void 0,
-    streamEndTime: void 0,
-    blocks: [],
-    currentBlockIndex: -1,
-    currentBlockType: "",
-    inputJsonBuffer: "",
-    audios: [],
-    videos: []
-  };
-  function parseOpenAIEvent(data) {
-    if (data === "[DONE]") {
-      debugSSE("OpenAI [DONE] received, content length:", state.content.length);
-      state.isDone = true;
-      callbacks.onDone?.();
-      return;
-    }
-    try {
-      const json = JSON.parse(data);
-      callbacks.onRawEvent?.({ data: json, raw: data });
-      const delta = json.choices?.[0]?.delta;
-      const finishReason = json.choices?.[0]?.finish_reason;
-      if (finishReason) {
-        debugSSE("OpenAI finish_reason:", finishReason, "content length so far:", state.content.length);
-      }
-      if (delta?.content) {
-        if (!state.firstTokenTime) {
-          state.firstTokenTime = Date.now();
-        }
-        state.content += delta.content;
-        callbacks.onDelta?.(delta.content);
-      }
-      if (delta?.reasoning_content) {
-        state.reasoning += delta.reasoning_content;
-        callbacks.onReasoning?.(delta.reasoning_content);
-      }
-      if (delta?.audio) {
-        const audioData = delta.audio;
-        if (audioData.data) {
-          const mimeType = audioData.format ? `audio/${audioData.format}` : "audio/wav";
-          const audio = {
-            url: audioData.data.startsWith("data:") ? audioData.data : `data:${mimeType};base64,${audioData.data}`,
-            mimeType
-          };
-          state.audios.push(audio);
-          callbacks.onAudio?.(audio);
-        }
-      }
-      if (json.usage) {
-        debugSSE("OpenAI usage received:", JSON.stringify(json.usage));
-        debugSSE("OpenAI final chunk full data:", JSON.stringify(json));
-        state.usage = {
-          promptTokens: json.usage.prompt_tokens || 0,
-          completionTokens: json.usage.completion_tokens || 0,
-          totalTokens: json.usage.total_tokens || 0
-        };
-        callbacks.onUsage?.(state.usage);
-      }
-      if (finishReason === "stop" || finishReason === "end_turn" || finishReason === "length") {
-        debugSSE("OpenAI stream marked done due to finish_reason:", finishReason);
-      }
-    } catch {
-    }
-  }
-  function parseAnthropicEvent(data) {
-    try {
-      const json = JSON.parse(data);
-      callbacks.onRawEvent?.({ type: json.type, data: json, raw: data });
-      if (json.type === "content_block_start") {
-        const contentBlock = json.content_block;
-        const blockIndex = json.index ?? -1;
-        if (contentBlock?.type === "thinking") {
-          debugSSE("THINKING BLOCK STARTED!");
-        }
-        if (contentBlock?.type === "server_tool_use") {
-          state.currentBlockIndex = blockIndex;
-          state.currentBlockType = "server_tool_use";
-          state.inputJsonBuffer = "";
-          const toolUseBlock = {
-            id: contentBlock.id || `block_${Date.now()}`,
-            type: "tool_use",
-            toolId: contentBlock.id || "",
-            toolName: contentBlock.name || "web_search",
-            input: contentBlock.input || {},
-            status: "running"
-          };
-          state.blocks.push(toolUseBlock);
-          callbacks.onBlock?.(toolUseBlock);
-        }
-        if (contentBlock?.type === "web_search_tool_result") {
-          state.currentBlockIndex = blockIndex;
-          state.currentBlockType = "web_search_tool_result";
-          const searchResults = contentBlock.content;
-          let output = "";
-          if (Array.isArray(searchResults)) {
-            output = searchResults.filter((r) => r.type === "web_search_result").map(
-              (r) => `**${r.title || "Untitled"}**
-${r.url || ""}
-${r.encrypted_content ? "(encrypted)" : r.page_content || r.snippet || ""}`
-            ).join("\n\n");
-          }
-          const lastToolUse = [...state.blocks].reverse().find(
-            (b) => b.type === "tool_use"
-          );
-          const toolResultBlock = {
-            id: `result_${Date.now()}`,
-            type: "tool_result",
-            toolId: lastToolUse?.toolId || "",
-            toolName: lastToolUse?.toolName || "web_search",
-            output: output || "(no results)"
-          };
-          state.blocks.push(toolResultBlock);
-          callbacks.onBlock?.(toolResultBlock);
-          if (lastToolUse) {
-            lastToolUse.status = "completed";
-            callbacks.onBlock?.(lastToolUse);
-          }
-        }
-      }
-      if (json.type === "content_block_delta") {
-        const delta = json.delta;
-        if (delta?.type === "text_delta" && delta?.text) {
-          if (!state.firstTokenTime) {
-            state.firstTokenTime = Date.now();
-          }
-          state.content += delta.text;
-          callbacks.onDelta?.(delta.text);
-        }
-        if (delta?.type === "thinking_delta" && delta?.thinking) {
-          state.reasoning += delta.thinking;
-          callbacks.onReasoning?.(delta.thinking);
-        }
-        if (delta?.type === "input_json_delta" && delta?.partial_json) {
-          state.inputJsonBuffer += delta.partial_json;
-        }
-      }
-      if (json.type === "content_block_stop") {
-        if (state.currentBlockType === "server_tool_use" && state.inputJsonBuffer) {
-          const lastToolUse = [...state.blocks].reverse().find(
-            (b) => b.type === "tool_use"
-          );
-          if (lastToolUse) {
-            try {
-              lastToolUse.input = JSON.parse(state.inputJsonBuffer);
-            } catch {
-              lastToolUse.input = { raw: state.inputJsonBuffer };
-            }
-            callbacks.onBlock?.(lastToolUse);
-          }
-        }
-        state.currentBlockIndex = -1;
-        state.currentBlockType = "";
-        state.inputJsonBuffer = "";
-      }
-      if (json.type === "message_delta" && json.usage) {
-        state.usage = {
-          promptTokens: json.usage.input_tokens || 0,
-          completionTokens: json.usage.output_tokens || 0,
-          totalTokens: (json.usage.input_tokens || 0) + (json.usage.output_tokens || 0)
-        };
-        callbacks.onUsage?.(state.usage);
-      }
-      if (json.type === "message_stop") {
-        state.isDone = true;
-        callbacks.onDone?.();
-      }
-      if (json.type === "error") {
-        callbacks.onError?.(json.error?.message || "Unknown error");
-      }
-    } catch {
-    }
-  }
-  function parseGeminiEvent(data) {
-    try {
-      const json = JSON.parse(data);
-      callbacks.onRawEvent?.({ data: json, raw: data });
-      const candidates = json.candidates;
-      if (candidates && candidates.length > 0) {
-        const candidate = candidates[0];
-        const content = candidate.content;
-        if (content?.parts) {
-          for (const part of content.parts) {
-            if (part.thought === true && part.text) {
-              state.reasoning += part.text;
-              callbacks.onReasoning?.(part.text);
-            } else if (part.text) {
-              if (!state.firstTokenTime) {
-                state.firstTokenTime = Date.now();
-              }
-              state.content += part.text;
-              callbacks.onDelta?.(part.text);
-            }
-          }
-        }
-        const finishReason = candidate.finishReason;
-        if (finishReason === "STOP" || finishReason === "MAX_TOKENS" || finishReason === "SAFETY") {
-          debugSSE("Gemini finish reason:", finishReason);
-        }
-      }
-      const usage = json.usageMetadata;
-      if (usage) {
-        state.usage = {
-          promptTokens: usage.promptTokenCount || 0,
-          completionTokens: usage.candidatesTokenCount || 0,
-          totalTokens: usage.totalTokenCount || 0
-        };
-        callbacks.onUsage?.(state.usage);
-        debugSSE("Gemini usage:", state.usage);
-      }
-      if (json.error) {
-        callbacks.onError?.(json.error.message || "Gemini API error");
-      }
-    } catch {
-    }
-  }
-  function parseOpenAIResponseEvent(data) {
-    try {
-      const json = JSON.parse(data);
-      callbacks.onRawEvent?.({ type: json.type, data: json, raw: data });
-      switch (json.type) {
-        case "response.output_text.delta":
-          if (json.delta) {
-            if (!state.firstTokenTime) {
-              state.firstTokenTime = Date.now();
-            }
-            state.content += json.delta;
-            callbacks.onDelta?.(json.delta);
-          }
-          break;
-        case "response.reasoning_summary_text.delta":
-          if (json.delta) {
-            state.reasoning += json.delta;
-            callbacks.onReasoning?.(json.delta);
-          }
-          break;
-        case "response.completed": {
-          const response = json.response;
-          if (response?.usage) {
-            state.usage = {
-              promptTokens: response.usage.input_tokens || 0,
-              completionTokens: response.usage.output_tokens || 0,
-              totalTokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0)
-            };
-            callbacks.onUsage?.(state.usage);
-          }
-          state.isDone = true;
-          callbacks.onDone?.();
-          break;
-        }
-        case "error":
-          callbacks.onError?.(json.error?.message || json.message || "Unknown error");
-          break;
-        // Informational events — no-op
-        // response.created, response.in_progress, response.output_item.added,
-        // response.content_part.added, response.output_text.done,
-        // response.content_part.done, response.output_item.done, etc.
-        default:
-          break;
-      }
-    } catch {
-    }
-  }
-  function processEventBlock(eventBlock) {
-    const lines = eventBlock.split("\n");
-    const dataLines = [];
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        dataLines.push(line.slice(6));
-      } else if (line.trim() !== "" && !line.startsWith(":")) {
-      }
-    }
-    if (dataLines.length > 0) {
-      const data = dataLines.join("\n");
-      if (format === "openai") {
-        parseOpenAIEvent(data);
-      } else if (format === "gemini") {
-        parseGeminiEvent(data);
-      } else if (format === "openai-response") {
-        parseOpenAIResponseEvent(data);
-      } else {
-        parseAnthropicEvent(data);
-      }
-    }
-  }
-  return {
-    /**
-     * Push a chunk of data to the parser
-     * @param chunk - Raw SSE chunk from response stream
-     */
-    push(chunk) {
-      if (state.isDone) return;
-      if (!state.streamStartTime) {
-        state.streamStartTime = Date.now();
-      }
-      state.buffer += chunk;
-      const events = state.buffer.split("\n\n");
-      state.buffer = events.pop() || "";
-      for (const eventBlock of events) {
-        processEventBlock(eventBlock);
-        if (state.isDone) break;
-      }
-    },
-    /**
-     * Flush any remaining data in the buffer
-     */
-    flush() {
-      debugSSE("flush() called, buffer length:", state.buffer.length, "isDone:", state.isDone);
-      if (state.buffer.trim()) {
-        debugSSE("flush() processing remaining buffer:", state.buffer.substring(0, 200));
-        processEventBlock(state.buffer);
-        state.buffer = "";
-      }
-      state.streamEndTime = Date.now();
-      if (!state.isDone) {
-        debugSSE("flush() marking stream as done, final content length:", state.content.length);
-        state.isDone = true;
-        callbacks.onDone?.();
-      }
-    },
-    /**
-     * Get accumulated results
-     */
-    getResult() {
-      let metrics;
-      if (state.usage && state.firstTokenTime && state.streamEndTime) {
-        const timeCompletionMs = state.streamEndTime - state.firstTokenTime;
-        const timeFirstTokenMs = state.streamStartTime ? state.firstTokenTime - state.streamStartTime : void 0;
-        metrics = {
-          completionTokens: state.usage.completionTokens,
-          timeCompletionMs: timeCompletionMs > 0 ? timeCompletionMs : 1,
-          // Ensure at least 1ms
-          timeFirstTokenMs
-        };
-      }
-      if (state.reasoning) {
-        const thinkingBlock = {
-          id: `thinking_${Date.now()}`,
-          type: "thinking",
-          content: state.reasoning
-        };
-        state.blocks.unshift(thinkingBlock);
-      }
-      return {
-        content: state.content,
-        reasoning: state.reasoning,
-        usage: state.usage,
-        metrics,
-        blocks: state.blocks,
-        audios: state.audios,
-        videos: state.videos
-      };
-    },
-    /**
-     * Check if stream is complete
-     */
-    isDone() {
-      return state.isDone;
-    },
-    /**
-     * Reset parser state for reuse
-     */
-    reset() {
-      state.buffer = "";
-      state.content = "";
-      state.reasoning = "";
-      state.usage = void 0;
-      state.isDone = false;
-      state.streamStartTime = void 0;
-      state.firstTokenTime = void 0;
-      state.streamEndTime = void 0;
-      state.blocks = [];
-      state.currentBlockIndex = -1;
-      state.currentBlockType = "";
-      state.inputJsonBuffer = "";
-      state.audios = [];
-      state.videos = [];
-    }
-  };
-}
-async function streamSSEResponse(response, format, callbacks) {
-  debugSSE("streamSSEResponse started, format:", format);
-  const reader = response.body?.getReader();
-  if (!reader) {
-    callbacks.onError?.("No response body");
-    return { content: "", reasoning: "", blocks: [], audios: [], videos: [] };
-  }
-  const decoder = new TextDecoder();
-  const parser = createSSEParser(format, callbacks);
-  let chunkCount = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        debugSSE("Reader done signal received after", chunkCount, "chunks");
-        break;
-      }
-      const chunk = decoder.decode(value, { stream: true });
-      chunkCount++;
-      parser.push(chunk);
-      if (parser.isDone()) {
-        debugSSE("Parser isDone after", chunkCount, "chunks");
-        break;
-      }
-    }
-    parser.flush();
-    const result = parser.getResult();
-    debugSSE("streamSSEResponse complete, content length:", result.content.length, "completionTokens:", result.usage?.completionTokens, "usage:", result.usage);
-    return result;
-  } finally {
-    reader.releaseLock();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createSSEParser,
-  streamSSEResponse
-});
+
+var _chunkHQP3K7PUcjs = require('./chunk-HQP3K7PU.cjs');
+
+
+
+exports.createSSEParser = _chunkHQP3K7PUcjs.createSSEParser; exports.streamSSEResponse = _chunkHQP3K7PUcjs.streamSSEResponse;