@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-SVNDB62D.cjs

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/serializeError.ts
+function serializeError(err) {
+  if (err == null) return "Unknown error (null)";
+  if (err instanceof Error) {
+    let msg = err.message || err.name || "Error";
+    if (err.cause) {
+      msg += ` [cause: ${serializeError(err.cause)}]`;
+    }
+    const anyErr = err;
+    if (anyErr.status != null) msg += ` (status: ${anyErr.status})`;
+    else if (anyErr.code != null) msg += ` (code: ${anyErr.code})`;
+    return msg;
+  }
+  if (typeof err === "string") return err || "Empty error string";
+  if (typeof err !== "object") return String(err);
+  const obj = err;
+  if (typeof obj.message === "string" && obj.message) {
+    let msg = obj.message;
+    if (obj.status != null) msg += ` (status: ${obj.status})`;
+    else if (obj.code != null) msg += ` (code: ${obj.code})`;
+    if (typeof obj.type === "string") msg += ` [type: ${obj.type}]`;
+    return msg;
+  }
+  if (typeof obj.error === "string" && obj.error) {
+    return obj.error;
+  }
+  if (obj.error && typeof obj.error === "object") {
+    const inner = obj.error;
+    if (typeof inner.message === "string" && inner.message) {
+      let msg = inner.message;
+      if (typeof inner.type === "string") msg += ` [type: ${inner.type}]`;
+      return msg;
+    }
+  }
+  try {
+    const json = JSON.stringify(err, getCircularReplacer(), 2);
+    if (json && json.length > 1e3) {
+      return json.slice(0, 1e3) + "... (truncated)";
+    }
+    return json || "Unserializable error";
+  } catch (e) {
+    return `Unserializable error: ${Object.prototype.toString.call(err)}`;
+  }
+}
+function getCircularReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+
+
+
+exports.serializeError = serializeError;

package/dist/chunk-UYPEN5XE.cjs

@@ -0,0 +1,235 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _class;
+
+var _chunk7YN22L2Hcjs = require('./chunk-7YN22L2H.cjs');
+
+
+var _chunk2DCNB7DFcjs = require('./chunk-2DCNB7DF.cjs');
+
+
+var _chunkC72S6TTVcjs = require('./chunk-C72S6TTV.cjs');
+
+
+var _chunkDWKQZ2SKcjs = require('./chunk-DWKQZ2SK.cjs');
+
+
+var _chunk4VAVYUZScjs = require('./chunk-4VAVYUZS.cjs');
+
+
+var _chunkRSJ3TWJQcjs = require('./chunk-RSJ3TWJQ.cjs');
+
+// src/transformer/transformers/DeepseekTransformer.ts
+var DeepseekTransformer = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  static __initStatic() {this.TransformerName = "deepseek"}
+  __init() {this.name = "deepseek"}
+  
+  /**
+   * 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 = _optionalChain([request, 'access', _ => _.model, 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3("deepseek-v4")]);
+    if (!isV4 && request.max_tokens && request.max_tokens > 8192) {
+      _optionalChain([this, 'access', _4 => _4.logger, 'optionalAccess', _5 => _5.debug, 'call', _6 => _6("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 = _nullishCoalesce(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 (_optionalChain([jsonResponse, 'access', _7 => _7.choices, 'optionalAccess', _8 => _8[0], 'optionalAccess', _9 => _9.message, 'optionalAccess', _10 => _10.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 (_optionalChain([data, 'access', _11 => _11.choices, 'optionalAccess', _12 => _12[0], 'optionalAccess', _13 => _13.delta, 'optionalAccess', _14 => _14.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 (_optionalChain([data, 'access', _15 => _15.choices, 'optionalAccess', _16 => _16[0], 'optionalAccess', _17 => _17.delta, 'optionalAccess', _18 => _18.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 (_optionalChain([data, 'access', _19 => _19.choices, 'optionalAccess', _20 => _20[0], 'optionalAccess', _21 => _21.delta, 'optionalAccess', _22 => _22.reasoning_content])) {
+                delete data.choices[0].delta.reasoning_content;
+              }
+              if (_optionalChain([data, 'access', _23 => _23.choices, 'optionalAccess', _24 => _24[0], 'optionalAccess', _25 => _25.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) {
+                _optionalChain([this, 'access', _26 => _26.logger, 'optionalAccess', _27 => _27.error, 'call', _28 => _28("Error processing DeepSeek stream line:", error)]);
+                controller.enqueue(encoder.encode(line + "\n"));
+              }
+            }
+          }
+        } catch (error) {
+          _optionalChain([this, 'access', _29 => _29.logger, 'optionalAccess', _30 => _30.error, 'call', _31 => _31("DeepSeek stream error:", error)]);
+          controller.error(error);
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch (e) {
+            _optionalChain([this, 'access', _32 => _32.logger, 'optionalAccess', _33 => _33.error, 'call', _34 => _34("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"
+      })
+    });
+  }
+}, _class.__initStatic(), _class);
+
+// src/transformer/transformers/index.ts
+var BuiltinTransformers = {
+  DeepseekTransformer,
+  ReasoningTransformer: _chunkDWKQZ2SKcjs.ReasoningTransformer,
+  GeminiTransformer: _chunk7YN22L2Hcjs.GeminiTransformer,
+  GeminiCodeAssistTransformer: _chunkRSJ3TWJQcjs.GeminiCodeAssistTransformer,
+  AnthropicTransformer: _chunk4VAVYUZScjs.AnthropicTransformer,
+  OpenAIResponseTransformer: _chunk2DCNB7DFcjs.OpenAIResponseTransformer,
+  OpenCodeGoTransformer: _chunkC72S6TTVcjs.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());
+}
+
+
+
+
+
+
+
+exports.DeepseekTransformer = DeepseekTransformer; exports.BuiltinTransformers = BuiltinTransformers; exports.getBuiltinTransformers = getBuiltinTransformers; exports.BUILTIN_TRANSFORMER_NAMES = BUILTIN_TRANSFORMER_NAMES; exports.registerBuiltinTransformers = registerBuiltinTransformers;

package/dist/chunk-V5KPWNYX.cjs

@@ -0,0 +1,147 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunk6VIXXLMXcjs = require('./chunk-6VIXXLMX.cjs');
+
+
+
+
+
+var _chunkGMMT7RVNcjs = require('./chunk-GMMT7RVN.cjs');
+
+// src/completion/NativeSearchInjector.ts
+function detectNativeSearch(modelId, apiFormat, provider, userExplicit) {
+  if (_chunk6VIXXLMXcjs.isOpenRouterProvider.call(void 0, provider)) {
+    return { supported: true, nativeProvider: "openrouter" };
+  }
+  if (isXaiProvider(provider)) {
+    return { supported: true, nativeProvider: "xai" };
+  }
+  if (apiFormat === "openai" && _chunkGMMT7RVNcjs.OPENAI_CHAT_COMPLETION_SEARCH_MODELS.some((m) => modelId.startsWith(m))) {
+    return { supported: true, nativeProvider: "openai" };
+  }
+  const formatProvider = _chunkGMMT7RVNcjs.API_FORMAT_PROVIDER_MAP[apiFormat];
+  if (formatProvider) {
+    const patterns = _chunkGMMT7RVNcjs.NATIVE_SEARCH_MODEL_PATTERNS[formatProvider];
+    if (patterns.some((re) => re.test(modelId))) {
+      if (!_chunkGMMT7RVNcjs.NATIVE_SEARCH_EXCLUDED_MODELS.some((m) => modelId.startsWith(m))) {
+        return { supported: true, nativeProvider: formatProvider };
+      }
+    }
+  }
+  if (userExplicit && formatProvider) {
+    return { supported: true, nativeProvider: formatProvider };
+  }
+  return { supported: false, nativeProvider: null };
+}
+function buildNativeSearchAugmentation(nativeProvider, config, _apiFormat, modelId) {
+  if (!config.enabled) return null;
+  switch (nativeProvider) {
+    case "openai":
+      return buildOpenAIAugmentation(config, modelId);
+    case "anthropic":
+      return buildAnthropicAugmentation(config);
+    case "google":
+      return buildGoogleAugmentation(modelId);
+    case "xai":
+      return buildXaiAugmentation(config);
+    case "openrouter":
+      return buildOpenRouterAugmentation(config);
+    default:
+      return null;
+  }
+}
+function applyAugmentation(requestBody, augmentation) {
+  if (_optionalChain([augmentation, 'access', _ => _.additionalTools, 'optionalAccess', _2 => _2.length])) {
+    const existing = _nullishCoalesce(requestBody.tools, () => ( []));
+    requestBody.tools = [...existing, ...augmentation.additionalTools];
+  }
+  if (augmentation.bodyFields) {
+    Object.assign(requestBody, augmentation.bodyFields);
+  }
+  return requestBody;
+}
+function buildOpenAIAugmentation(config, modelId) {
+  const isChatCompletionSearch = _chunkGMMT7RVNcjs.OPENAI_CHAT_COMPLETION_SEARCH_MODELS.some(
+    (m) => modelId.startsWith(m)
+  );
+  if (isChatCompletionSearch) {
+    return {
+      bodyFields: {
+        web_search_options: {
+          search_context_size: config.maxResults ? mapMaxResultsToContextSize(config.maxResults) : "medium"
+        }
+      }
+    };
+  }
+  return {
+    additionalTools: [
+      {
+        type: "web_search",
+        web_search: {
+          search_context_size: config.maxResults ? mapMaxResultsToContextSize(config.maxResults) : "medium"
+        }
+      }
+    ]
+  };
+}
+function buildAnthropicAugmentation(config) {
+  const toolDef = {
+    type: "web_search_20250305",
+    name: "web_search"
+  };
+  if (config.maxResults) {
+    toolDef.max_uses = config.maxResults;
+  }
+  if (_optionalChain([config, 'access', _3 => _3.blockedDomains, 'optionalAccess', _4 => _4.length])) {
+    toolDef.blocked_domains = config.blockedDomains;
+  }
+  return { additionalTools: [toolDef] };
+}
+function buildGoogleAugmentation(modelId) {
+  const isLegacy = /gemini-1[._]/.test(modelId);
+  if (isLegacy) {
+    return {
+      additionalTools: [
+        { googleSearchRetrieval: {} }
+      ]
+    };
+  }
+  return {
+    additionalTools: [
+      { google_search: {} }
+    ]
+  };
+}
+function buildXaiAugmentation(config) {
+  const searchParams = {
+    mode: _nullishCoalesce(config.searchMode, () => ( "auto")),
+    return_citations: true,
+    max_search_results: _nullishCoalesce(config.maxResults, () => ( 5))
+  };
+  if (_optionalChain([config, 'access', _5 => _5.sources, 'optionalAccess', _6 => _6.length])) {
+    searchParams.sources = config.sources;
+  }
+  return { bodyFields: { search_parameters: searchParams } };
+}
+function buildOpenRouterAugmentation(config) {
+  const plugin = { id: "web" };
+  if (config.maxResults) {
+    plugin.max_results = config.maxResults;
+  }
+  return { bodyFields: { plugins: [plugin] } };
+}
+function isXaiProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("x.ai") || baseUrl.includes("xai.com");
+}
+function mapMaxResultsToContextSize(maxResults) {
+  if (maxResults <= 2) return "low";
+  if (maxResults <= 5) return "medium";
+  return "high";
+}
+
+
+
+
+
+exports.detectNativeSearch = detectNativeSearch; exports.buildNativeSearchAugmentation = buildNativeSearchAugmentation; exports.applyAugmentation = applyAugmentation;