@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-JO5NLTLY.js

@@ -0,0 +1,46 @@
+// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      responseChainRequest ?? requestBody,
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+export {
+  executeProviderCall
+};

package/dist/chunk-JWC6APFQ.js

@@ -0,0 +1,23 @@
+// src/pipeline/resolveProviderChain.ts
+async function resolveProviderChain(llmConfig, providerId, model) {
+  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
+  const mainTransformer = await llmConfig.getMainTransformer(providerId);
+  const chain = {
+    providerTransformers: [...cachedChain.providerTransformers],
+    modelTransformers: [...cachedChain.modelTransformers]
+  };
+  if (mainTransformer) {
+    const alreadyInChain = chain.providerTransformers.some(
+      (t) => t.name === mainTransformer.name
+    );
+    if (!alreadyInChain) {
+      chain.providerTransformers.unshift(mainTransformer);
+    }
+  }
+  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
+  return { chain, mainTransformer, hasTransformers };
+}
+
+export {
+  resolveProviderChain
+};

package/dist/chunk-KUU2RNG6.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      _nullishCoalesce(responseChainRequest, () => ( requestBody)),
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+
+
+exports.executeProviderCall = executeProviderCall;

package/dist/chunk-L74VDN4A.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/pipeline/billingEmit.ts
+var sink = null;
+var captureConfig = null;
+function setBillingSink(fn) {
+  sink = fn;
+}
+function setBillingCaptureConfig(config) {
+  captureConfig = config && config.enabled ? config : null;
+}
+function getBillingCaptureConfig() {
+  return captureConfig;
+}
+function publishBillingEvent(event) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(event);
+  } catch (e) {
+  }
+}
+function __resetBillingSinkForTests() {
+  sink = null;
+  captureConfig = null;
+}
+
+
+
+
+
+
+
+exports.setBillingSink = setBillingSink; exports.setBillingCaptureConfig = setBillingCaptureConfig; exports.getBillingCaptureConfig = getBillingCaptureConfig; exports.publishBillingEvent = publishBillingEvent; exports.__resetBillingSinkForTests = __resetBillingSinkForTests;

package/dist/chunk-MQNDWYPN.js

@@ -0,0 +1,235 @@
+import {
+  OpenCodeGoTransformer
+} from "./chunk-Z7LUNECE.js";
+import {
+  ReasoningTransformer
+} from "./chunk-ZJZAOKI7.js";
+import {
+  AnthropicTransformer
+} from "./chunk-FTQ7IQUC.js";
+import {
+  GeminiTransformer
+} from "./chunk-C7PSERMH.js";
+import {
+  OpenAIResponseTransformer
+} from "./chunk-5HTVET6E.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
+};

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

@@ -0,0 +1,56 @@
+import {
+  serializeError
+} from "./chunk-AVYJ4YBN.js";
+
+// 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;
+  }
+  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,
+        sessionKey: hints.sessionKey,
+        reportSelection: hints.reportSelection
+      });
+    } catch (err) {
+      console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", serializeError(err));
+    }
+  }
+  /** Delegate the 401-refresh decision to the bound strategy, threading the
+   *  session key so the account actually served is the one refreshed (D7). */
+  async onUnauthorized(sessionKey) {
+    return this.profile.authStrategy.onUnauthorized(sessionKey);
+  }
+  /** Resolve the upstream URL from the profile, when it provides one. */
+  resolveUpstreamUrl(model) {
+    return this.profile.resolveUpstreamUrl?.(model);
+  }
+};
+
+export {
+  stripAuthHeaders,
+  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;