@omnicross/core 0.1.10 → 0.2.1

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
+};

package/dist/chunk-N76KU6F5.js

@@ -0,0 +1,123 @@
+// src/outbound-api/auditRedact.ts
+var AUDIT_REDACTED = "***REDACTED***";
+var RULES = [
+  // `sk-…` family (Anthropic sk-ant-, omnicross sk-omnicross-, OpenAI sk-proj-/sk-).
+  { re: /\bsk-[A-Za-z0-9_-]{6,}/g, replace: AUDIT_REDACTED },
+  // Google API keys.
+  { re: /\bAIza[A-Za-z0-9_-]{10,}/g, replace: AUDIT_REDACTED },
+  // `Bearer <token>` (auth headers echoed into a body / SSE error).
+  { re: /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/gi, replace: `Bearer ${AUDIT_REDACTED}` },
+  // Inline `x-api-key` / `api-key` / `authorization` label followed by a value.
+  {
+    re: /\b(x-api-key|api[_-]?key|authorization)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  },
+  // `x-goog-api-key` header echoed inline.
+  {
+    re: /\b(x-goog-api-key)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  }
+];
+function redactEncryptedContentValue(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    for (const item of value) changed2 = redactEncryptedContentValue(item) || changed2;
+    return changed2;
+  }
+  let changed = false;
+  const record = value;
+  for (const [key, nested] of Object.entries(record)) {
+    if (key === "encrypted_content") {
+      record[key] = AUDIT_REDACTED;
+      changed = true;
+    } else {
+      changed = redactEncryptedContentValue(nested) || changed;
+    }
+  }
+  return changed;
+}
+function redactJsonValue(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return redactEncryptedContentValue(parsed) ? JSON.stringify(parsed) : null;
+  } catch {
+    return null;
+  }
+}
+function redactEncryptedContentSse(text) {
+  return text.replace(/^(\s*data:\s*)([^\r\n]*)(\r?)$/gm, (line, prefix, payload, cr) => {
+    if (!payload || payload.trim() === "[DONE]") return line;
+    const redacted = redactJsonValue(payload.trim());
+    return redacted === null ? line : `${prefix}${redacted}${cr}`;
+  });
+}
+function findJsonLikeValueEnd(text, start) {
+  const first = text[start];
+  if (first === '"' || first === "'") {
+    let escaped = false;
+    for (let index = start + 1; index < text.length; index += 1) {
+      const char = text[index];
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === first) return index + 1;
+    }
+    return text.length;
+  }
+  if (first === "{" || first === "[") {
+    const opening = first;
+    const closing = first === "{" ? "}" : "]";
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = start; index < text.length; index += 1) {
+      const char = text[index];
+      if (quote) {
+        if (escaped) escaped = false;
+        else if (char === "\\") escaped = true;
+        else if (char === quote) quote = "";
+        continue;
+      }
+      if (char === '"' || char === "'") quote = char;
+      else if (char === opening) depth += 1;
+      else if (char === closing && --depth === 0) return index + 1;
+    }
+    return text.length;
+  }
+  let end = start;
+  while (end < text.length && !/[\r\n,}\]]/.test(text[end])) end += 1;
+  return end;
+}
+function redactEncryptedContentText(text) {
+  const key = /["']encrypted_content["']\s*:\s*/g;
+  let output = "";
+  let cursor = 0;
+  for (; ; ) {
+    const match = key.exec(text);
+    if (!match) break;
+    const valueStart = match.index + match[0].length;
+    const valueEnd = findJsonLikeValueEnd(text, valueStart);
+    output += text.slice(cursor, valueStart) + JSON.stringify(AUDIT_REDACTED);
+    cursor = valueEnd;
+    key.lastIndex = valueEnd;
+  }
+  return cursor === 0 ? text : output + text.slice(cursor);
+}
+function redactEncryptedContent(text) {
+  const completeJson = redactJsonValue(text);
+  if (completeJson !== null) return completeJson;
+  return redactEncryptedContentText(redactEncryptedContentSse(text));
+}
+function redactAuditText(text) {
+  if (typeof text !== "string" || text.length === 0) return text ?? "";
+  let out = redactEncryptedContent(text);
+  for (const { re, replace } of RULES) {
+    out = out.replace(re, replace);
+  }
+  return out;
+}
+
+export {
+  AUDIT_REDACTED,
+  redactAuditText
+};