@omnicross/core 0.1.1 → 0.1.3

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-WNY4WMRF.js

@@ -0,0 +1,32 @@
+// src/pipeline/auditSink.ts
+var sink = null;
+var captureConfig = null;
+function setAuditSink(fn) {
+  sink = fn;
+}
+function setAuditCaptureConfig(config) {
+  captureConfig = config && config.enabled ? config : null;
+}
+function getAuditCaptureConfig() {
+  return captureConfig;
+}
+function recordAudit(record) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(record);
+  } catch {
+  }
+}
+function __resetAuditSinkForTests() {
+  sink = null;
+  captureConfig = null;
+}
+
+export {
+  setAuditSink,
+  setAuditCaptureConfig,
+  getAuditCaptureConfig,
+  recordAudit,
+  __resetAuditSinkForTests
+};

package/dist/chunk-XEKD23J5.js

@@ -0,0 +1,9 @@
+// src/outbound-api/types.ts
+var ENDPOINT_MODEL_KINDS = {
+  messages: ["fable", "opus", "sonnet", "haiku"],
+  responses: ["codex", "mini"]
+};
+
+export {
+  ENDPOINT_MODEL_KINDS
+};

package/dist/chunk-XTEI64OU.js

@@ -0,0 +1,145 @@
+import {
+  refreshNonStainless,
+  sanitizeFrozenHeaders
+} from "./chunk-XX6NQJMA.js";
+
+// src/provider-proxy/identity/SubscriptionIdentityStore.ts
+var CC_HEADER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var KEY_SEP = "\0";
+function normalizeUa(ua) {
+  if (typeof ua !== "string") return void 0;
+  const trimmed = ua.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var SubscriptionIdentityStore = class {
+  identities = /* @__PURE__ */ new Map();
+  now;
+  enabled;
+  ua;
+  ccHeaderTtlMs;
+  persistence = null;
+  constructor(opts = {}) {
+    this.now = opts.now ?? Date.now;
+    this.enabled = opts.enabled ?? false;
+    this.ua = normalizeUa(opts.ua);
+    this.ccHeaderTtlMs = opts.ccHeaderTtlMs ?? CC_HEADER_TTL_MS;
+  }
+  /** Whether capture/replay is engaged (config flag). */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** The operator UA baseline (piece 4), or undefined when unset. */
+  uaBaseline() {
+    return this.ua;
+  }
+  /**
+   * Re-apply config to the LIVE shared instance (bootstrap, mirroring the health
+   * tracker's `configure`). Only defined fields override; `ua: null` clears the
+   * baseline.
+   */
+  configure(opts) {
+    if (opts.enabled !== void 0) this.enabled = opts.enabled;
+    if (opts.ua !== void 0) this.ua = normalizeUa(opts.ua ?? void 0);
+  }
+  /** Install (or clear) the write-through persistence port (P2). */
+  setPersistence(port) {
+    this.persistence = port;
+  }
+  /**
+   * Boot seed (P2, D5): install a PERSISTED identity for an account, but NEVER
+   * over a live in-memory capture (a re-captured identity from this session wins).
+   * A no-op for an empty/absent identity. Does NOT write back through the port.
+   */
+  seed(providerId, accountId, identity) {
+    if (!accountId || !identity) return;
+    const headers = sanitizeFrozenHeaders(identity.headers ?? {});
+    if (Object.keys(headers).length === 0) return;
+    const key = this.key(providerId, accountId);
+    if (this.identities.has(key)) return;
+    this.identities.set(key, {
+      headers,
+      capturedAt: typeof identity.capturedAt === "number" ? identity.capturedAt : this.now()
+    });
+  }
+  /**
+   * Capture a real client's fingerprint headers for an account. First-seen ⇒
+   * FREEZE the whole (sanitized) bag. Already-frozen ⇒ within the TTL, no change
+   * (stable identity); past the TTL, refresh the NON-stainless headers from the
+   * new observation while keeping stainless frozen-stable (P2). An empty/absent
+   * account id or an empty sanitized bag is a no-op (so an account with no
+   * fingerprint headers never freezes an empty identity → the caller falls back
+   * to the UA baseline). Fires the persistence port on a freeze/refresh.
+   */
+  capture(providerId, accountId, incoming, now = this.now()) {
+    if (!accountId) return;
+    const clean = sanitizeFrozenHeaders(incoming);
+    if (Object.keys(clean).length === 0) return;
+    const key = this.key(providerId, accountId);
+    const existing = this.identities.get(key);
+    if (!existing) {
+      const frozen = { headers: clean, capturedAt: now };
+      this.identities.set(key, frozen);
+      this.emitPersist(providerId, accountId, frozen);
+      return;
+    }
+    if (now - existing.capturedAt < this.ccHeaderTtlMs) return;
+    const refreshed = {
+      headers: refreshNonStainless(existing.headers, clean),
+      capturedAt: now
+    };
+    this.identities.set(key, refreshed);
+    this.emitPersist(providerId, accountId, refreshed);
+  }
+  /**
+   * The frozen identity headers for an account, or `undefined` when none is
+   * frozen (or the frozen set is empty). Returns a COPY (the caller merges it into
+   * a mutable outbound header bag).
+   */
+  replay(providerId, accountId) {
+    if (!accountId) return void 0;
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    if (!frozen || Object.keys(frozen.headers).length === 0) return void 0;
+    return { ...frozen.headers };
+  }
+  /** Whether an identity is frozen for an account (admin coarse status — D7). */
+  hasIdentity(providerId, accountId) {
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    return !!frozen && Object.keys(frozen.headers).length > 0;
+  }
+  /** The freeze/refresh time for an account's identity (admin coarse status). */
+  capturedAt(providerId, accountId) {
+    return this.identities.get(this.key(providerId, accountId))?.capturedAt;
+  }
+  emitPersist(providerId, accountId, identity) {
+    if (!this.persistence) return;
+    try {
+      this.persistence.persist(providerId, accountId, {
+        headers: { ...identity.headers },
+        capturedAt: identity.capturedAt
+      });
+    } catch {
+    }
+  }
+  key(providerId, accountId) {
+    return `${providerId}${KEY_SEP}${accountId}`;
+  }
+};
+var _shared = null;
+function getSharedIdentityStore() {
+  if (!_shared) _shared = new SubscriptionIdentityStore();
+  return _shared;
+}
+function setSharedIdentityStore(instance) {
+  _shared = instance;
+}
+function __resetSharedIdentityStoreForTests() {
+  _shared = null;
+}
+
+export {
+  CC_HEADER_TTL_MS,
+  SubscriptionIdentityStore,
+  getSharedIdentityStore,
+  setSharedIdentityStore,
+  __resetSharedIdentityStoreForTests
+};