@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-HQP3K7PU.cjs

@@ -0,0 +1,431 @@
+"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; }// 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;
+      _optionalChain([callbacks, 'access', _ => _.onDone, 'optionalCall', _2 => _2()]);
+      return;
+    }
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _3 => _3.onRawEvent, 'optionalCall', _4 => _4({ data: json, raw: data })]);
+      const delta = _optionalChain([json, 'access', _5 => _5.choices, 'optionalAccess', _6 => _6[0], 'optionalAccess', _7 => _7.delta]);
+      const finishReason = _optionalChain([json, 'access', _8 => _8.choices, 'optionalAccess', _9 => _9[0], 'optionalAccess', _10 => _10.finish_reason]);
+      if (finishReason) {
+        debugSSE("OpenAI finish_reason:", finishReason, "content length so far:", state.content.length);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _11 => _11.content])) {
+        if (!state.firstTokenTime) {
+          state.firstTokenTime = Date.now();
+        }
+        state.content += delta.content;
+        _optionalChain([callbacks, 'access', _12 => _12.onDelta, 'optionalCall', _13 => _13(delta.content)]);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _14 => _14.reasoning_content])) {
+        state.reasoning += delta.reasoning_content;
+        _optionalChain([callbacks, 'access', _15 => _15.onReasoning, 'optionalCall', _16 => _16(delta.reasoning_content)]);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _17 => _17.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);
+          _optionalChain([callbacks, 'access', _18 => _18.onAudio, 'optionalCall', _19 => _19(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
+        };
+        _optionalChain([callbacks, 'access', _20 => _20.onUsage, 'optionalCall', _21 => _21(state.usage)]);
+      }
+      if (finishReason === "stop" || finishReason === "end_turn" || finishReason === "length") {
+        debugSSE("OpenAI stream marked done due to finish_reason:", finishReason);
+      }
+    } catch (e) {
+    }
+  }
+  function parseAnthropicEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _22 => _22.onRawEvent, 'optionalCall', _23 => _23({ type: json.type, data: json, raw: data })]);
+      if (json.type === "content_block_start") {
+        const contentBlock = json.content_block;
+        const blockIndex = _nullishCoalesce(json.index, () => ( -1));
+        if (_optionalChain([contentBlock, 'optionalAccess', _24 => _24.type]) === "thinking") {
+          debugSSE("THINKING BLOCK STARTED!");
+        }
+        if (_optionalChain([contentBlock, 'optionalAccess', _25 => _25.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);
+          _optionalChain([callbacks, 'access', _26 => _26.onBlock, 'optionalCall', _27 => _27(toolUseBlock)]);
+        }
+        if (_optionalChain([contentBlock, 'optionalAccess', _28 => _28.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: _optionalChain([lastToolUse, 'optionalAccess', _29 => _29.toolId]) || "",
+            toolName: _optionalChain([lastToolUse, 'optionalAccess', _30 => _30.toolName]) || "web_search",
+            output: output || "(no results)"
+          };
+          state.blocks.push(toolResultBlock);
+          _optionalChain([callbacks, 'access', _31 => _31.onBlock, 'optionalCall', _32 => _32(toolResultBlock)]);
+          if (lastToolUse) {
+            lastToolUse.status = "completed";
+            _optionalChain([callbacks, 'access', _33 => _33.onBlock, 'optionalCall', _34 => _34(lastToolUse)]);
+          }
+        }
+      }
+      if (json.type === "content_block_delta") {
+        const delta = json.delta;
+        if (_optionalChain([delta, 'optionalAccess', _35 => _35.type]) === "text_delta" && _optionalChain([delta, 'optionalAccess', _36 => _36.text])) {
+          if (!state.firstTokenTime) {
+            state.firstTokenTime = Date.now();
+          }
+          state.content += delta.text;
+          _optionalChain([callbacks, 'access', _37 => _37.onDelta, 'optionalCall', _38 => _38(delta.text)]);
+        }
+        if (_optionalChain([delta, 'optionalAccess', _39 => _39.type]) === "thinking_delta" && _optionalChain([delta, 'optionalAccess', _40 => _40.thinking])) {
+          state.reasoning += delta.thinking;
+          _optionalChain([callbacks, 'access', _41 => _41.onReasoning, 'optionalCall', _42 => _42(delta.thinking)]);
+        }
+        if (_optionalChain([delta, 'optionalAccess', _43 => _43.type]) === "input_json_delta" && _optionalChain([delta, 'optionalAccess', _44 => _44.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 (e2) {
+              lastToolUse.input = { raw: state.inputJsonBuffer };
+            }
+            _optionalChain([callbacks, 'access', _45 => _45.onBlock, 'optionalCall', _46 => _46(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)
+        };
+        _optionalChain([callbacks, 'access', _47 => _47.onUsage, 'optionalCall', _48 => _48(state.usage)]);
+      }
+      if (json.type === "message_stop") {
+        state.isDone = true;
+        _optionalChain([callbacks, 'access', _49 => _49.onDone, 'optionalCall', _50 => _50()]);
+      }
+      if (json.type === "error") {
+        _optionalChain([callbacks, 'access', _51 => _51.onError, 'optionalCall', _52 => _52(_optionalChain([json, 'access', _53 => _53.error, 'optionalAccess', _54 => _54.message]) || "Unknown error")]);
+      }
+    } catch (e3) {
+    }
+  }
+  function parseGeminiEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _55 => _55.onRawEvent, 'optionalCall', _56 => _56({ data: json, raw: data })]);
+      const candidates = json.candidates;
+      if (candidates && candidates.length > 0) {
+        const candidate = candidates[0];
+        const content = candidate.content;
+        if (_optionalChain([content, 'optionalAccess', _57 => _57.parts])) {
+          for (const part of content.parts) {
+            if (part.thought === true && part.text) {
+              state.reasoning += part.text;
+              _optionalChain([callbacks, 'access', _58 => _58.onReasoning, 'optionalCall', _59 => _59(part.text)]);
+            } else if (part.text) {
+              if (!state.firstTokenTime) {
+                state.firstTokenTime = Date.now();
+              }
+              state.content += part.text;
+              _optionalChain([callbacks, 'access', _60 => _60.onDelta, 'optionalCall', _61 => _61(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
+        };
+        _optionalChain([callbacks, 'access', _62 => _62.onUsage, 'optionalCall', _63 => _63(state.usage)]);
+        debugSSE("Gemini usage:", state.usage);
+      }
+      if (json.error) {
+        _optionalChain([callbacks, 'access', _64 => _64.onError, 'optionalCall', _65 => _65(json.error.message || "Gemini API error")]);
+      }
+    } catch (e4) {
+    }
+  }
+  function parseOpenAIResponseEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _66 => _66.onRawEvent, 'optionalCall', _67 => _67({ 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;
+            _optionalChain([callbacks, 'access', _68 => _68.onDelta, 'optionalCall', _69 => _69(json.delta)]);
+          }
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (json.delta) {
+            state.reasoning += json.delta;
+            _optionalChain([callbacks, 'access', _70 => _70.onReasoning, 'optionalCall', _71 => _71(json.delta)]);
+          }
+          break;
+        case "response.completed": {
+          const response = json.response;
+          if (_optionalChain([response, 'optionalAccess', _72 => _72.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)
+            };
+            _optionalChain([callbacks, 'access', _73 => _73.onUsage, 'optionalCall', _74 => _74(state.usage)]);
+          }
+          state.isDone = true;
+          _optionalChain([callbacks, 'access', _75 => _75.onDone, 'optionalCall', _76 => _76()]);
+          break;
+        }
+        case "error":
+          _optionalChain([callbacks, 'access', _77 => _77.onError, 'optionalCall', _78 => _78(_optionalChain([json, 'access', _79 => _79.error, 'optionalAccess', _80 => _80.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 (e5) {
+    }
+  }
+  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;
+        _optionalChain([callbacks, 'access', _81 => _81.onDone, 'optionalCall', _82 => _82()]);
+      }
+    },
+    /**
+     * 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 = _optionalChain([response, 'access', _83 => _83.body, 'optionalAccess', _84 => _84.getReader, 'call', _85 => _85()]);
+  if (!reader) {
+    _optionalChain([callbacks, 'access', _86 => _86.onError, 'optionalCall', _87 => _87("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:", _optionalChain([result, 'access', _88 => _88.usage, 'optionalAccess', _89 => _89.completionTokens]), "usage:", result.usage);
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+
+
+
+exports.createSSEParser = createSSEParser; exports.streamSSEResponse = streamSSEResponse;

package/dist/chunk-HUZZZ3JL.js

@@ -0,0 +1,32 @@
+// src/openrouter.ts
+function isOpenRouterProvider(provider) {
+  const baseUrl = (provider.api_base_url || "").toLowerCase();
+  return baseUrl.includes("openrouter.ai");
+}
+var DEFAULT_APP_IDENTITY = {
+  referer: "https://github.com/Dumoedss/omnicross",
+  title: "Omnicross"
+};
+var OPENROUTER_APP_HEADERS = {
+  "HTTP-Referer": DEFAULT_APP_IDENTITY.referer,
+  "X-Title": DEFAULT_APP_IDENTITY.title
+};
+function setOpenRouterAppIdentity(identity) {
+  const referer = identity.referer?.trim();
+  const title = identity.title?.trim();
+  if (referer) OPENROUTER_APP_HEADERS["HTTP-Referer"] = referer;
+  if (title) OPENROUTER_APP_HEADERS["X-Title"] = title;
+}
+function getOpenRouterAppIdentity() {
+  return {
+    referer: OPENROUTER_APP_HEADERS["HTTP-Referer"],
+    title: OPENROUTER_APP_HEADERS["X-Title"]
+  };
+}
+
+export {
+  isOpenRouterProvider,
+  OPENROUTER_APP_HEADERS,
+  setOpenRouterAppIdentity,
+  getOpenRouterAppIdentity
+};

package/dist/chunk-IAXWICZU.js

@@ -0,0 +1,69 @@
+// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+function deriveSubscriptionSessionKey(anthropicBody) {
+  const system = flattenMatchText(anthropicBody.system).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let firstUser = "";
+  for (const message of messages) {
+    if (message && typeof message === "object" && message.role === "user") {
+      firstUser = flattenMatchText(message.content).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      break;
+    }
+  }
+  const anchor = `${system}\0${firstUser}`;
+  if (!system && !firstUser) return void 0;
+  return fnv1a(anchor);
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+export {
+  MATCH_TEXT_PER_MESSAGE_CAP,
+  MATCH_TEXT_RECENT_MESSAGES,
+  flattenMatchText,
+  collectMatchText,
+  deriveSubscriptionSessionKey
+};

package/dist/chunk-JMJBSACD.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 _chunkGMMT7RVNcjs = require('./chunk-GMMT7RVN.cjs');
+
+
+var _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
+
+// src/completion/NativeSearchInjector.ts
+function detectNativeSearch(modelId, apiFormat, provider, userExplicit) {
+  if (_chunkUNEFIWXIcjs.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;