@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-FFALUUZZ.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 _chunkC72S6TTVcjs = require('./chunk-C72S6TTV.cjs');
+
+
+var _chunkDWKQZ2SKcjs = require('./chunk-DWKQZ2SK.cjs');
+
+
+var _chunk4VAVYUZScjs = require('./chunk-4VAVYUZS.cjs');
+
+
+var _chunk7YN22L2Hcjs = require('./chunk-7YN22L2H.cjs');
+
+
+var _chunk2DCNB7DFcjs = require('./chunk-2DCNB7DF.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-FMOBD2OQ.js

@@ -0,0 +1,39 @@
+// src/completion/native-search-types.ts
+var NATIVE_SEARCH_MODEL_PATTERNS = {
+  openai: [/^gpt-4/, /^o[134]/, /^gpt-5/],
+  // Claude 3.x: claude-3-opus-*, claude-3-5-sonnet-*, etc.
+  // Claude 4.x: claude-sonnet-4-*, claude-opus-4-*, claude-haiku-4-*, etc.
+  anthropic: [/^claude-/],
+  google: [/^gemini-(?:2|3|flash|pro)/],
+  xai: [/^grok/],
+  openrouter: []
+  // Detected via provider, not model pattern
+};
+var OPENAI_CHAT_COMPLETION_SEARCH_MODELS = [
+  "gpt-4o-search-preview",
+  "gpt-4o-mini-search-preview",
+  "gpt-5-search-api"
+];
+var NATIVE_SEARCH_EXCLUDED_MODELS = [
+  "gpt-4.1-nano"
+];
+var NATIVE_SEARCH_TOOL_NAMES = [
+  "web_search",
+  "web_search_20250305",
+  "web_search_20260209",
+  "google_search",
+  "googleSearchRetrieval"
+];
+var API_FORMAT_PROVIDER_MAP = {
+  "openai-response": "openai",
+  anthropic: "anthropic",
+  google: "google"
+};
+
+export {
+  NATIVE_SEARCH_MODEL_PATTERNS,
+  OPENAI_CHAT_COMPLETION_SEARCH_MODELS,
+  NATIVE_SEARCH_EXCLUDED_MODELS,
+  NATIVE_SEARCH_TOOL_NAMES,
+  API_FORMAT_PROVIDER_MAP
+};