@omnicross/core 0.2.0 → 0.2.1

package/dist/{chunk-DEIUR2TH.js → chunk-LQYS2N47.js}

@@ -1765,7 +1765,10 @@ async function readJsonBody(request2, options) {
 
 // src/image-generation/openai-images/types.ts
 var DEFAULT_IMAGE_API_LIMITS = Object.freeze({
-  maxJsonBytes: 1024 * 1024,
+  // Codex's built-in image tool sends edits as JSON data URLs rather than
+  // multipart files. Leave room for the Base64 expansion of the bounded
+  // aggregate input budget plus the small JSON/options envelope.
+  maxJsonBytes: 96 * 1024 * 1024,
   maxMultipartBytes: 64 * 1024 * 1024,
   maxFileBytes: 50 * 1024 * 1024,
   maxTotalInputBytes: 64 * 1024 * 1024,
@@ -2326,7 +2329,7 @@ async function readMultipartEdit(request2, scope, limits, signal) {
 function invalid4(param = "image") {
   throw new ImageGenerationError("invalid_image_request", { param });
 }
-function closedInput(value, maxRemoteUrlBytes) {
+function closedInput(value, limits) {
   if (!value || typeof value !== "object" || Array.isArray(value)) invalid4();
   const record2 = value;
   const keys = Object.keys(record2);
@@ -2334,8 +2337,9 @@ function closedInput(value, maxRemoteUrlBytes) {
   const key = keys[0];
   if (key !== "file_id" && key !== "image_url") invalid4();
   const item = record2[key];
-  const maxBytes = key === "file_id" ? 256 : maxRemoteUrlBytes;
-  if (typeof item !== "string" || !item || Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
+  if (typeof item !== "string" || !item) invalid4();
+  const maxBytes = key === "file_id" ? 256 : item.toLowerCase().startsWith("data:") ? Math.ceil(limits.maxFileBytes / 3) * 4 + 64 : limits.maxRemoteUrlBytes;
+  if (Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
   return { [key]: item };
 }
 function decodedBase64Length(value) {
@@ -2407,7 +2411,7 @@ async function resolveReference(referenceId, runtime, scope) {
   return asset;
 }
 async function resolveImageInput(value, runtime, scope, signal) {
-  const input = closedInput(value, runtime.limits.maxRemoteUrlBytes);
+  const input = closedInput(value, runtime.limits);
   if ("file_id" in input) return resolveReference(input.file_id, runtime, scope);
   if (input.image_url.toLowerCase().startsWith("data:")) {
     return resolveDataUrl(input.image_url, runtime, scope, signal);
@@ -2432,10 +2436,10 @@ async function resolveImageInput(value, runtime, scope, signal) {
     materializer
   });
 }
-function parseImageInputList(value, maxRemoteUrlBytes) {
+function parseImageInputList(value, limits) {
   const list = Array.isArray(value) ? value : [value];
   if (list.length < 1 || list.length > 16) invalid4();
-  for (const item of list) closedInput(item, maxRemoteUrlBytes);
+  for (const item of list) closedInput(item, limits);
   return list;
 }
 
@@ -2481,7 +2485,7 @@ function createImageEditHandler(deps) {
         });
         const inputs = parseImageInputList(
           record2.images ?? record2.image,
-          runtime.limits.maxRemoteUrlBytes
+          runtime.limits
         );
         const resolveObservedInput = async (input) => {
           const reference = isReferenceInput(input);

package/dist/{chunk-NZYN7C3P.cjs → chunk-MPXOKQJP.cjs}

@@ -1,20 +1,7 @@
 "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 _searchtypes = require('@omnicross/contracts/search-types');
 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",
@@ -50,10 +37,19 @@ var WEB_FETCH_TOOL = {
   isBuiltIn: true
 };
 var BuiltinToolExecutor = class {
-  constructor(webSearch) {
+  /**
+   * @param webSearch - the legacy port, still the `web_fetch` URL reader.
+   * @param runtime - the search runtime `web_search` delegates to. Optional so
+   *   the single-argument construction hosts already use keeps compiling; when
+   *   omitted, a default runtime over the builtin HTTP providers is built on
+   *   first use.
+   */
+  constructor(webSearch, runtime) {
     this.webSearch = webSearch;
+    this.runtime = runtime;
   }
   
+  
   async execute(toolName, args) {
     switch (toolName) {
       case "web_search":
@@ -73,47 +69,51 @@ var BuiltinToolExecutor = class {
       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}
+    let response;
+    try {
+      response = await (await this.getRuntime()).search({
+        query,
+        options: { maxResults: count }
+      });
+    } catch (err) {
+      const shape = _searchtypes.toSearchErrorShape.call(void 0, err);
+      return {
+        isError: false,
+        content: [{ type: "text", text: `Search failed (${shape.code}): ${shape.message}` }]
+      };
+    }
+    if (response.results.length === 0) {
+      return {
+        isError: false,
+        content: [{ type: "text", text: `No results found for "${query}" after trying ${response.attempts.length} provider(s). Try rephrasing your search.` }]
+      };
+    }
+    const text = response.results.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.` }]
-    };
+    return { isError: false, content: [{ type: "text", text }] };
   }
-  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;
+  /** Memoized lazy construction, so concurrent first calls share one runtime. */
+  
+  /**
+   * The runtime `web_search` delegates to.
+   *
+   * Imported lazily so the search stack's transport and HTML parsing stay out
+   * of the module graph of every consumer that only wants the tool definitions
+   * — the same reason `builtin-web-fetch` is loaded on demand below.
+   *
+   * The PROMISE is memoized, not just its result: two concurrent first searches
+   * would otherwise each build a runtime and the later one would win. Harmless
+   * while the default runtime is stateless, but it stops being harmless the
+   * moment one holds a connection pool or a cache.
+   */
+  getRuntime() {
+    if (this.runtime !== void 0) return Promise.resolve(this.runtime);
+    this.runtimeInit ??= Promise.resolve().then(() => _interopRequireWildcard(require("./runtime-6QXNU526.cjs"))).then(({ createSearchRuntime }) => {
+      this.runtime = createSearchRuntime();
+      return this.runtime;
+    });
+    return this.runtimeInit;
   }
   // -----------------------------------------------------------------------
   // web_fetch

package/dist/chunk-MZEGQSKQ.js

@@ -0,0 +1,118 @@
+// src/search/frontends.ts
+var SEARCH_FRONTEND_NAMES = Object.freeze([
+  "codex",
+  "responses",
+  "anthropic"
+]);
+var SEARCH_FRONTEND_MODES = Object.freeze([
+  "native",
+  "managed",
+  "off"
+]);
+var DEFAULT_SEARCH_FRONTEND_MODES = Object.freeze({
+  codex: "off",
+  responses: "native",
+  anthropic: "native"
+});
+var SEARCH_UNSUPPORTED_CAPABILITY_CODE = "unsupported_capability";
+function searchErrorHttpStatus(code) {
+  switch (code) {
+    case "rate_limited":
+      return 429;
+    case "timeout":
+      return 504;
+    case "cancelled":
+      return 499;
+    case "config_missing":
+      return 503;
+    case "auth_failed":
+    case "upstream_unavailable":
+    case "parse_failed":
+    case "policy_denied":
+      return 502;
+    default:
+      return 502;
+  }
+}
+function isSearchFrontendMode(value) {
+  return typeof value === "string" && SEARCH_FRONTEND_MODES.includes(value);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeSearchFrontendModes(value) {
+  const raw = record(value) ?? {};
+  const modes = {
+    ...DEFAULT_SEARCH_FRONTEND_MODES
+  };
+  for (const name of SEARCH_FRONTEND_NAMES) {
+    const candidate = raw[name];
+    if (isSearchFrontendMode(candidate)) modes[name] = candidate;
+  }
+  return Object.freeze(modes);
+}
+function validateSearchFrontendModes(value, path = "$.search.modes") {
+  if (value === void 0) return [];
+  const raw = record(value);
+  if (!raw) return [`${path}: expected an object`];
+  const errors = [];
+  for (const [key, candidate] of Object.entries(raw)) {
+    if (!SEARCH_FRONTEND_NAMES.includes(key)) {
+      errors.push(`${path}.${key}: unknown frontend (expected ${SEARCH_FRONTEND_NAMES.join(", ")})`);
+      continue;
+    }
+    if (isSearchFrontendMode(candidate)) continue;
+    errors.push(
+      `${path}.${key}: not a mode (got ${typeof candidate}; expected ${SEARCH_FRONTEND_MODES.join(", ")})`
+    );
+  }
+  return errors;
+}
+
+// src/search/webSearchBackendCompat.ts
+import {
+  searchErrorToLegacyWebSearchResponse,
+  toLegacyWebSearchResponse
+} from "@omnicross/contracts/search-compat";
+import { toSearchErrorShape } from "@omnicross/contracts/search-types";
+function searchRuntimeAsWebSearchBackend(runtime, options = {}) {
+  return {
+    async search(query, providerId, searchOptions) {
+      try {
+        const response = await runtime.search({
+          query,
+          provider: providerId,
+          // `WebSearchOptions` is a strict subset of `SearchOptions` with
+          // identical field names — asserted in the contracts tests.
+          ...searchOptions === void 0 ? {} : { options: searchOptions }
+        });
+        return toLegacyWebSearchResponse(response);
+      } catch (error) {
+        return searchErrorToLegacyWebSearchResponse(query, toSearchErrorShape(error));
+      }
+    },
+    isProviderEnabled(id) {
+      return runtime.listProviders().some((descriptor) => descriptor.id === id);
+    },
+    async readUrl(url, readOptions) {
+      if (options.readUrl !== void 0) return options.readUrl(url, readOptions);
+      return {
+        success: false,
+        url,
+        error: "URL reading is not available through the search runtime adapter"
+      };
+    }
+  };
+}
+
+export {
+  SEARCH_FRONTEND_NAMES,
+  SEARCH_FRONTEND_MODES,
+  DEFAULT_SEARCH_FRONTEND_MODES,
+  SEARCH_UNSUPPORTED_CAPABILITY_CODE,
+  searchErrorHttpStatus,
+  isSearchFrontendMode,
+  normalizeSearchFrontendModes,
+  validateSearchFrontendModes,
+  searchRuntimeAsWebSearchBackend
+};