@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-VVEHS2LI.js

@@ -0,0 +1,431 @@
+// src/sse-parser.ts
+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();
+  }
+}
+
+export {
+  createSSEParser,
+  streamSSEResponse
+};

package/dist/chunk-XBSYYZIY.cjs

@@ -0,0 +1,94 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/usage/usage-recorder.ts
+var UsageRecorder = class {
+  constructor(store, pricing, logger, options = {}) {
+    this.store = store;
+    this.pricing = pricing;
+    this.logger = logger;
+    this.defer = _nullishCoalesce(options.defer, () => ( ((fn) => setTimeout(fn, 0))));
+  }
+  
+  
+  
+  
+  /**
+   * Record one LLM request. Returns immediately — the actual store insert is
+   * deferred so the caller's response path is unblocked.
+   *
+   * Errors during the insert are logged but never thrown.
+   */
+  record(input) {
+    this.defer(() => {
+      void this.recordAsync(input).catch((err) => {
+        this.logger.warn("[UsageRecorder] failed to persist usage event", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    });
+  }
+  /**
+   * Same as `record()` but awaitable — preferred in tests so they can assert
+   * after the row exists.
+   */
+  async recordAsync(input) {
+    const { costUsd, costSavedByCacheUsd } = await this.pricing.calculateCost(
+      input.providerId,
+      input.model,
+      input.usage
+    );
+    const row = {
+      messageId: _nullishCoalesce(input.messageId, () => ( null)),
+      parentMessageId: _nullishCoalesce(input.parentMessageId, () => ( null)),
+      sessionId: _nullishCoalesce(input.sessionId, () => ( null)),
+      providerId: input.providerId,
+      model: input.model,
+      apiKeyId: _nullishCoalesce(input.apiKeyId, () => ( null)),
+      engineOrigin: input.engineOrigin,
+      inputTokens: input.usage.inputTokens,
+      outputTokens: input.usage.outputTokens,
+      cacheReadTokens: input.usage.cacheReadTokens,
+      cacheCreationTokens: input.usage.cacheCreationTokens,
+      reasoningTokens: input.usage.reasoningTokens,
+      costUsd,
+      costSavedByCacheUsd,
+      rawUsage: input.rawUsage != null ? safeStringify(input.rawUsage) : null,
+      runId: _nullishCoalesce(input.runId, () => ( null)),
+      eventId: _nullishCoalesce(input.eventId, () => ( null))
+    };
+    try {
+      return await this.store.insert(row);
+    } catch (err) {
+      this.logger.warn("[UsageRecorder] store insert failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  // ===== Query delegates =====
+  getTotals(range) {
+    return this.store.getTotals(range);
+  }
+  getByModel(range) {
+    return this.store.getByModel(range);
+  }
+  getByApiKey(range) {
+    return this.store.getByApiKey(range);
+  }
+  getMessagesForSession(sessionId) {
+    return this.store.getMessagesForSession(sessionId);
+  }
+  /** Cumulative cache hit/miss stats for one session. */
+  getSessionCacheStats(sessionId) {
+    return this.store.getSessionCacheStats(sessionId);
+  }
+};
+var safeStringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return "";
+  }
+};
+
+
+
+exports.UsageRecorder = UsageRecorder;