@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-MNYKI4CI.js

@@ -0,0 +1,94 @@
+// src/usage/usage-recorder.ts
+var UsageRecorder = class {
+  constructor(store, pricing, logger, options = {}) {
+    this.store = store;
+    this.pricing = pricing;
+    this.logger = logger;
+    this.defer = options.defer ?? ((fn) => setTimeout(fn, 0));
+  }
+  store;
+  pricing;
+  logger;
+  defer;
+  /**
+   * 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: input.messageId ?? null,
+      parentMessageId: input.parentMessageId ?? null,
+      sessionId: input.sessionId ?? null,
+      providerId: input.providerId,
+      model: input.model,
+      apiKeyId: 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: input.runId ?? null,
+      eventId: 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 {
+    return "";
+  }
+};
+
+export {
+  UsageRecorder
+};

package/dist/chunk-MZNPGW5Q.js

@@ -0,0 +1,26 @@
+// src/transformer/anthropicBetaInject.ts
+import { isExtendedContextCapable } from "@omnicross/contracts/extended-context";
+var EXTENDED_CONTEXT_BETA = "context-1m-2025-08-07";
+var ANTHROPIC_BETA_HEADER = "anthropic-beta";
+function injectExtendedContextBeta(headers, model, useExtendedContext) {
+  if (!useExtendedContext) return;
+  if (!isExtendedContextCapable(model)) return;
+  let existingValue = "";
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === ANTHROPIC_BETA_HEADER) {
+      const v = headers[key];
+      if (typeof v === "string") existingValue = v;
+      if (key !== ANTHROPIC_BETA_HEADER) delete headers[key];
+    }
+  }
+  const parts = existingValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (!parts.includes(EXTENDED_CONTEXT_BETA)) {
+    parts.push(EXTENDED_CONTEXT_BETA);
+  }
+  headers[ANTHROPIC_BETA_HEADER] = parts.join(",");
+}
+
+export {
+  EXTENDED_CONTEXT_BETA,
+  injectExtendedContextBeta
+};

package/dist/chunk-N3V2J5ZO.cjs

@@ -0,0 +1,53 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkSVNDB62Dcjs = require('./chunk-SVNDB62D.cjs');
+
+// src/pipeline/SubscriptionAuthSource.ts
+function stripAuthHeaders(headers) {
+  delete headers.authorization;
+  delete headers.Authorization;
+  delete headers["x-api-key"];
+  delete headers["X-Api-Key"];
+  delete headers["x-goog-api-key"];
+  delete headers["X-Goog-Api-Key"];
+}
+var SubscriptionAuthSource = class {
+  constructor(profile) {
+    this.profile = profile;
+  }
+  
+  /**
+   * Strip any transformer-set auth headers, then delegate to the bound
+   * strategy. Mirrors `SubscriptionDispatcher`'s
+   * `stripAuthHeaders(...)` + `applyHeadersWithRetry(...)` sequence, including
+   * the best-effort swallow-and-warn around a throwing `applyHeaders`.
+   *
+   * The strategy's looser `AuthApplyHints` (optional `upstreamUrl` /
+   * `resolvedModel`) is fed from the pipeline's required `{ upstreamUrl,
+   * model }` at the boundary.
+   */
+  async applyHeaders(headers, hints) {
+    stripAuthHeaders(headers);
+    try {
+      await this.profile.authStrategy.applyHeaders(headers, {
+        upstreamUrl: hints.upstreamUrl,
+        resolvedModel: hints.model
+      });
+    } catch (err) {
+      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", _chunkSVNDB62Dcjs.serializeError.call(void 0, err));
+    }
+  }
+  /** Delegate the 401-refresh decision to the bound strategy. */
+  async onUnauthorized() {
+    return this.profile.authStrategy.onUnauthorized();
+  }
+  /** Resolve the upstream URL from the profile, when it provides one. */
+  resolveUpstreamUrl(model) {
+    return _optionalChain([this, 'access', _ => _.profile, 'access', _2 => _2.resolveUpstreamUrl, 'optionalCall', _3 => _3(model)]);
+  }
+};
+
+
+
+
+exports.stripAuthHeaders = stripAuthHeaders; exports.SubscriptionAuthSource = SubscriptionAuthSource;

package/dist/chunk-NYUNU75A.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/resolveSubscriptionChain.ts
+function resolveOne(transformerService, name) {
+  const t = transformerService.getTransformer(name);
+  if (!t) return null;
+  return typeof t === "function" ? new t() : t;
+}
+function resolveSubscriptionChain(profile, transformerService, fallbackEndpoint, overrideNames) {
+  const providerNames = _nullishCoalesce(_nullishCoalesce(overrideNames, () => ( profile.providerTransformerNames)), () => ( []));
+  const modelNames = _nullishCoalesce(profile.modelTransformerNames, () => ( []));
+  if (providerNames.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers: [] };
+  }
+  if (!transformerService) {
+    throw new Error(
+      "[resolveSubscriptionChain] profile declares providerTransformerNames but no TransformerService is wired"
+    );
+  }
+  const providerTransformers = [];
+  for (const name of providerNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Transformer not registered: ${name}`);
+      continue;
+    }
+    providerTransformers.push(instance);
+  }
+  const modelTransformers = [];
+  for (const name of modelNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Model transformer not registered: ${name}`);
+      continue;
+    }
+    modelTransformers.push(instance);
+  }
+  if (providerTransformers.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers };
+  }
+  return { providerTransformers, modelTransformers };
+}
+
+
+
+exports.resolveSubscriptionChain = resolveSubscriptionChain;

package/dist/chunk-NZYN7C3P.cjs

@@ -0,0 +1,179 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/completion/BuiltinToolExecutor.ts
+var DEFAULT_SEARCH_COUNT = 5;
+var DEFAULT_FETCH_MAX_CHARS = 2e4;
+var FALLBACK_ORDER = [
+  "tavily",
+  "jina",
+  "searxng",
+  "zhipu",
+  "z.ai",
+  "bocha",
+  "grok",
+  "local-google",
+  "local-bing",
+  "local-baidu",
+  "local-duckduckgo"
+];
+var IMPLICIT_LOCAL_FALLBACK = "local-google";
+var WEB_SEARCH_TOOL = {
+  id: "builtin__web_search",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_search",
+  description: "Search the web for current information. Returns a list of results with title, URL, and snippet. Use web_fetch afterwards to get full page content if snippets are insufficient.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query." },
+      count: { type: "integer", description: "Maximum number of results (1-10).", default: DEFAULT_SEARCH_COUNT }
+    },
+    required: ["query"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var WEB_FETCH_TOOL = {
+  id: "builtin__web_fetch",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_fetch",
+  description: "Fetch and extract the main content of a web page as clean Markdown. Use this to read the full content of a URL found via web_search.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "The URL to fetch (http or https)." },
+      maxChars: { type: "integer", description: "Maximum characters to return.", default: DEFAULT_FETCH_MAX_CHARS }
+    },
+    required: ["url"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var BuiltinToolExecutor = class {
+  constructor(webSearch) {
+    this.webSearch = webSearch;
+  }
+  
+  async execute(toolName, args) {
+    switch (toolName) {
+      case "web_search":
+        return this.executeWebSearch(args);
+      case "web_fetch":
+        return this.executeWebFetch(args);
+      default:
+        return { isError: true, content: [{ type: "text", text: `Unknown built-in tool: ${toolName}` }] };
+    }
+  }
+  // -----------------------------------------------------------------------
+  // web_search
+  // -----------------------------------------------------------------------
+  async executeWebSearch(args) {
+    const query = String(_nullishCoalesce(args.query, () => ( ""))).trim();
+    if (!query) {
+      return { isError: true, content: [{ type: "text", text: "Error: query parameter is required." }] };
+    }
+    const count = Math.min(Math.max(Number(_nullishCoalesce(args.count, () => ( DEFAULT_SEARCH_COUNT))), 1), 10);
+    const chain = this.resolveProviderChain();
+    let lastError = "";
+    for (const providerId of chain) {
+      try {
+        const result = await this.webSearch.search(query, providerId, { maxResults: count });
+        if (!result.success) {
+          lastError = result.error || "Unknown error";
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} failed: ${lastError}, trying next...`);
+          continue;
+        }
+        const items = result.results.slice(0, count);
+        if (items.length === 0) {
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} returned 0 results, trying next...`);
+          continue;
+        }
+        const text = items.map((r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}
+   ${r.content || ""}`).join("\n\n");
+        return { isError: false, content: [{ type: "text", text }] };
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+        console.log(`[BuiltinToolExecutor] Search provider ${providerId} threw: ${lastError}, trying next...`);
+        continue;
+      }
+    }
+    return {
+      isError: false,
+      content: [{ type: "text", text: lastError ? `Search failed after trying ${chain.length} provider(s). Last error: ${lastError}` : `No results found for "${query}" after trying ${chain.length} provider(s). Try rephrasing your search.` }]
+    };
+  }
+  resolveProviderChain() {
+    const chain = [];
+    for (const id of FALLBACK_ORDER) {
+      if (this.webSearch.isProviderEnabled(id)) {
+        chain.push(id);
+      }
+    }
+    if (!chain.includes(IMPLICIT_LOCAL_FALLBACK)) {
+      chain.push(IMPLICIT_LOCAL_FALLBACK);
+    }
+    return chain;
+  }
+  // -----------------------------------------------------------------------
+  // web_fetch
+  // -----------------------------------------------------------------------
+  async executeWebFetch(args) {
+    const url = String(_nullishCoalesce(args.url, () => ( ""))).trim();
+    if (!url) {
+      return { isError: true, content: [{ type: "text", text: "Error: url parameter is required." }] };
+    }
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return { isError: true, content: [{ type: "text", text: "Error: only http and https URLs are supported." }] };
+      }
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: `Error: invalid URL "${url}".` }] };
+    }
+    const maxChars = Number(_nullishCoalesce(args.maxChars, () => ( DEFAULT_FETCH_MAX_CHARS)));
+    try {
+      const jinaResult = await this.webSearch.readUrl(url, { timeout: 15e3 });
+      if (jinaResult.success && jinaResult.content) {
+        const content = jinaResult.content.length > maxChars ? jinaResult.content.slice(0, maxChars) + "\n\n[Content truncated]" : jinaResult.content;
+        const header = jinaResult.title ? `# ${jinaResult.title}
+
+` : "";
+        return { isError: false, content: [{ type: "text", text: header + content }] };
+      }
+      const { fetchAndExtractUrl } = await Promise.resolve().then(() => _interopRequireWildcard(require("./builtin-web-fetch-77JZUZGM.cjs")));
+      const text = await fetchAndExtractUrl(url, maxChars);
+      return { isError: false, content: [{ type: "text", text }] };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { isError: true, content: [{ type: "text", text: `Fetch error: ${message}` }] };
+    }
+  }
+};
+function getBuiltinSearchTools() {
+  return [WEB_SEARCH_TOOL, WEB_FETCH_TOOL];
+}
+function convertBuiltinToolsToOpenAI(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.id,
+      description: t.description || t.name,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function convertBuiltinToolsToAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.id,
+    description: t.description || t.name,
+    input_schema: t.inputSchema
+  }));
+}
+
+
+
+
+
+
+exports.BuiltinToolExecutor = BuiltinToolExecutor; exports.getBuiltinSearchTools = getBuiltinSearchTools; exports.convertBuiltinToolsToOpenAI = convertBuiltinToolsToOpenAI; exports.convertBuiltinToolsToAnthropic = convertBuiltinToolsToAnthropic;

package/dist/chunk-O466Y272.js

@@ -0,0 +1,235 @@
+import {
+  GeminiTransformer
+} from "./chunk-C7PSERMH.js";
+import {
+  OpenAIResponseTransformer
+} from "./chunk-5HTVET6E.js";
+import {
+  OpenCodeGoTransformer
+} from "./chunk-Z7LUNECE.js";
+import {
+  ReasoningTransformer
+} from "./chunk-ZJZAOKI7.js";
+import {
+  AnthropicTransformer
+} from "./chunk-FTQ7IQUC.js";
+import {
+  GeminiCodeAssistTransformer
+} from "./chunk-Z7Y2NPHY.js";
+
+// src/transformer/transformers/DeepseekTransformer.ts
+var DeepseekTransformer = class {
+  static TransformerName = "deepseek";
+  name = "deepseek";
+  logger;
+  /**
+   * Transform request: limit max_tokens to 8192 for legacy models only
+   * V4 models support up to 384K output tokens
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const isV4 = request.model?.startsWith("deepseek-v4");
+    if (!isV4 && request.max_tokens && request.max_tokens > 8192) {
+      this.logger?.debug("DeepSeek: Limiting max_tokens from %d to 8192", request.max_tokens);
+      request.max_tokens = 8192;
+    }
+    return request;
+  }
+  /**
+   * Transform response: convert reasoning_content to thinking blocks
+   */
+  async transformResponseOut(response, _context) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("application/json")) {
+      return this.handleJsonResponse(response);
+    } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+      return this.handleStreamResponse(response);
+    }
+    return response;
+  }
+  /**
+   * Handle JSON (non-streaming) response
+   */
+  async handleJsonResponse(response) {
+    const jsonResponse = await response.json();
+    if (jsonResponse.choices?.[0]?.message?.reasoning_content) {
+      jsonResponse.choices[0].message.thinking = {
+        content: jsonResponse.choices[0].message.reasoning_content
+      };
+      delete jsonResponse.choices[0].message.reasoning_content;
+    }
+    return new Response(JSON.stringify(jsonResponse), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  /**
+   * Handle streaming response - convert reasoning_content to thinking blocks
+   */
+  async handleStreamResponse(response) {
+    if (!response.body) {
+      return response;
+    }
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let reasoningContent = "";
+    let isReasoningComplete = false;
+    let buffer = "";
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const reader = response.body.getReader();
+        const processLine = (line) => {
+          if (line.startsWith("data: ") && line.trim() !== "data: [DONE]") {
+            try {
+              const data = JSON.parse(line.slice(6));
+              if (data.choices?.[0]?.delta?.reasoning_content) {
+                reasoningContent += data.choices[0].delta.reasoning_content;
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        thinking: {
+                          content: data.choices[0].delta.reasoning_content
+                        }
+                      }
+                    }
+                  ]
+                };
+                delete thinkingChunk.choices[0].delta.reasoning_content;
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+                return;
+              }
+              if (data.choices?.[0]?.delta?.content && reasoningContent && !isReasoningComplete) {
+                isReasoningComplete = true;
+                const signature = Date.now().toString();
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        content: null,
+                        thinking: {
+                          signature
+                        }
+                      }
+                    }
+                  ]
+                };
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+              }
+              if (data.choices?.[0]?.delta?.reasoning_content) {
+                delete data.choices[0].delta.reasoning_content;
+              }
+              if (data.choices?.[0]?.delta && Object.keys(data.choices[0].delta).length > 0) {
+                if (isReasoningComplete) {
+                  data.choices[0].index++;
+                }
+                const modifiedLine = `data: ${JSON.stringify(data)}
+
+`;
+                controller.enqueue(encoder.encode(modifiedLine));
+              }
+            } catch (_e) {
+              controller.enqueue(encoder.encode(line + "\n"));
+            }
+          } else {
+            controller.enqueue(encoder.encode(line + "\n"));
+          }
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                const lines2 = buffer.split("\n");
+                for (const line of lines2) {
+                  if (line.trim()) {
+                    controller.enqueue(encoder.encode(line + "\n"));
+                  }
+                }
+              }
+              break;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                processLine(line);
+              } catch (error) {
+                this.logger?.error("Error processing DeepSeek stream line:", error);
+                controller.enqueue(encoder.encode(line + "\n"));
+              }
+            }
+          }
+        } catch (error) {
+          this.logger?.error("DeepSeek stream error:", error);
+          controller.error(error);
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch (e) {
+            this.logger?.error("Error releasing reader lock:", e);
+          }
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: new Headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      })
+    });
+  }
+};
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  DeepseekTransformer,
+  ReasoningTransformer,
+  GeminiTransformer,
+  GeminiCodeAssistTransformer,
+  AnthropicTransformer,
+  OpenAIResponseTransformer,
+  OpenCodeGoTransformer
+};
+function getBuiltinTransformers() {
+  return BuiltinTransformers;
+}
+var BUILTIN_TRANSFORMER_NAMES = [
+  "deepseek",
+  "reasoning",
+  "gemini",
+  "gemini-code-assist",
+  "anthropic",
+  "openai-response",
+  "opencodego"
+];
+async function registerBuiltinTransformers(service) {
+  await service.initialize(getBuiltinTransformers());
+}
+
+export {
+  DeepseekTransformer,
+  BuiltinTransformers,
+  getBuiltinTransformers,
+  BUILTIN_TRANSFORMER_NAMES,
+  registerBuiltinTransformers
+};