nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/chunk-FSO5B7GH.js

@@ -0,0 +1,171 @@
+import {
+  i18n_default,
+  toolRegistry
+} from "./chunk-AL2KDGR2.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-P3PKED2I.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/ai/tools/toolSchemaCompatibility.ts
+var COMPOSITION_KEYS = ["anyOf", "oneOf", "allOf"];
+var LIMITED_JSON_SCHEMA_PROVIDERS = /* @__PURE__ */ new Set([
+  "fireworks"
+]);
+var sanitizeSchemaNode = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeSchemaNode(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const next = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (COMPOSITION_KEYS.includes(key)) {
+      continue;
+    }
+    next[key] = sanitizeSchemaNode(child);
+  }
+  return next;
+};
+var shouldSanitizeProviderSchema = (provider) => LIMITED_JSON_SCHEMA_PROVIDERS.has(asTrimmedLowercaseString(provider));
+var sanitizeToolForProvider = (tool, provider) => {
+  if (!shouldSanitizeProviderSchema(provider)) {
+    return tool;
+  }
+  const parameters = tool?.function?.parameters;
+  if (!isRecord(parameters)) {
+    return tool;
+  }
+  return {
+    ...tool,
+    function: {
+      ...tool.function,
+      parameters: sanitizeSchemaNode(parameters)
+    }
+  };
+};
+
+// packages/ai/tools/prepareTools.ts
+var translatedFunctionCache = /* @__PURE__ */ new Map();
+var prepareToolsResultCache = /* @__PURE__ */ new Map();
+var PREPARE_TOOLS_CACHE_LIMIT = 128;
+function getTranslation(keys, defaultVal) {
+  for (const key of keys) {
+    if (i18n_default.exists(key)) {
+      return i18n_default.t(key);
+    }
+    const aiKey = key.startsWith("ai:") ? key : `ai:${key}`;
+    if (i18n_default.exists(aiKey)) {
+      return i18n_default.t(aiKey);
+    }
+  }
+  return defaultVal;
+}
+function translateSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const nextSchema = JSON.parse(JSON.stringify(schema));
+  const toolName = nextSchema.name;
+  if (!toolName) return nextSchema;
+  const walk = (node, path) => {
+    if (!node || typeof node !== "object") return;
+    if (typeof node.description === "string") {
+      const keysToTry = [
+        `${path}.description`,
+        `${path}.desc`,
+        path,
+        node.description
+      ];
+      node.description = getTranslation(keysToTry, node.description);
+    }
+    if (node.parameters && typeof node.parameters === "object") {
+      walk(node.parameters, path);
+    }
+    if (node.properties && typeof node.properties === "object") {
+      for (const [key, child] of Object.entries(node.properties)) {
+        const nextPath = path.endsWith(".params") ? `${path}.${key}` : `${path}.params.${key}`;
+        walk(child, nextPath);
+      }
+    }
+    if (node.items && typeof node.items === "object") {
+      walk(node.items, path);
+    }
+    const compositions = ["anyOf", "oneOf", "allOf"];
+    for (const comp of compositions) {
+      if (Array.isArray(node[comp])) {
+        node[comp].forEach((child, idx) => {
+          const suffix = child.type === "string" ? "stringDesc" : child.type === "object" ? "objectDesc" : `${idx}`;
+          walk(child, `${path}.${suffix}`);
+        });
+      }
+    }
+  };
+  walk(nextSchema, `tools.${toolName}`);
+  return nextSchema;
+}
+function currentI18nLanguage() {
+  return typeof i18n_default.language === "string" ? i18n_default.language : "";
+}
+function translateSchemaCached(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const toolName = typeof schema.name === "string" ? schema.name : "";
+  if (!toolName) return translateSchema(schema);
+  const cacheKey = `${currentI18nLanguage()}\0${toolName}`;
+  const hit = translatedFunctionCache.get(cacheKey);
+  if (hit) return hit;
+  const translated = translateSchema(schema);
+  translatedFunctionCache.set(cacheKey, translated);
+  return translated;
+}
+function buildPrepareToolsCacheKey(toolNames, disabledToolNames, provider) {
+  return [
+    currentI18nLanguage(),
+    provider ?? "",
+    disabledToolNames.join(""),
+    toolNames.join("")
+  ].join("\0");
+}
+function rememberPrepareToolsResult(key, value) {
+  if (prepareToolsResultCache.size >= PREPARE_TOOLS_CACHE_LIMIT) {
+    const oldest = prepareToolsResultCache.keys().next().value;
+    if (oldest !== void 0) {
+      prepareToolsResultCache.delete(oldest);
+    }
+  }
+  prepareToolsResultCache.set(key, value);
+}
+var prepareTools = (toolNames, options) => {
+  const disabledList = canonicalizeToolNames(options?.disabledToolNames ?? []);
+  const disabledToolNames = new Set(disabledList);
+  const canonicalNames = canonicalizeToolNames(toolNames).filter(
+    (toolName) => !disabledToolNames.has(toolName)
+  );
+  const cacheKey = buildPrepareToolsCacheKey(
+    canonicalNames,
+    disabledList,
+    options?.provider
+  );
+  const cached = prepareToolsResultCache.get(cacheKey);
+  if (cached) {
+    return cached.slice();
+  }
+  const prepared = canonicalNames.map((toolName) => {
+    const regTool = toolRegistry[toolName];
+    if (!regTool) return regTool;
+    return {
+      ...regTool,
+      function: translateSchemaCached(regTool.function)
+    };
+  }).map((tool) => sanitizeToolForProvider(tool, options?.provider)).filter(Boolean);
+  rememberPrepareToolsResult(cacheKey, prepared);
+  return prepared.slice();
+};
+
+export {
+  prepareTools
+};