nolo-cli 0.7.0 → 0.8.0-alpha.11

package/chunk-J5KV47ZW.js

@@ -0,0 +1,222 @@
+import {
+  clearCliLocalRuntimePreparedAgentCache
+} from "./chunk-YOUZDXU7.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  buildCreatedAgentRecord,
+  buildUpdatedAgentRecord,
+  normalizeAgentRecordForOutput,
+  parseAgentUpdateArgs,
+  resolveAgentRecordFromHybridStore,
+  sanitizeAgentRecordForCliOutput,
+  writeAgentRecord
+} from "./chunk-GGXABIPP.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken
+} from "./chunk-ISNCLGUZ.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+
+// packages/cli/agentRecordCommands.ts
+async function runAgentReadCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentInput = args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
+    output.write("Usage: nolo agent read <agent>\n");
+    return agentInput ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const result = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    if (!result) {
+      throw new Error(`agent not found: ${agentKey}`);
+    }
+    output.write(JSON.stringify({
+      ...normalizeAgentRecordForOutput(result.agentKey, authToken, result.record),
+      source: result.source
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent read failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentUpdateCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent update failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent update <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--max-concurrent <n>] [--expires-at <iso>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--field key=value]\n".replace("[--field key=value]", `[--handle <name>] [--field key=value]  (e.g. --field disabledTools='["exa_search"]' to disable default tools)`)
+    );
+    return args[0] ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent update could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const built = await buildUpdatedAgentRecord({
+      cliArgs: args,
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken
+    });
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl
+    });
+    clearCliLocalRuntimePreparedAgentCache();
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent update failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentCreateCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent create failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent create <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--max-concurrent <n>] [--expires-at <iso>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--name <name>] [--custom-provider-url <url>] [--provider-api-key <key>] [--field key=value]\n".replace("[--field key=value]", "[--handle <name>] [--field key=value]")
+    );
+    return args[0] ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent create requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent create could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const built = await buildCreatedAgentRecord({
+      cliArgs: args,
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken
+    });
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl
+    });
+    clearCliLocalRuntimePreparedAgentCache();
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent create failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+
+export {
+  runAgentReadCommand,
+  runAgentUpdateCommand,
+  runAgentCreateCommand
+};

package/chunk-JBTJAPUF.js

@@ -0,0 +1,35 @@
+// packages/connector-experimental/codexBinary.ts
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
+function pathEntries(env) {
+  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+}
+function findWindowsAppsCodex(env) {
+  if (process.platform !== "win32") return "";
+  for (const entry of pathEntries(env)) {
+    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
+    const candidate = join(entry, "codex.exe");
+    if (existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function copyCodexToUserBin(source, env) {
+  const target = env.NOLO_CODEX_SHIM_PATH ?? join(homedir(), ".nolo", "bin", "codex.exe");
+  if (existsSync(target)) return target;
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(source, target);
+  return target;
+}
+function resolveLaunchableCodexCommand(env = process.env) {
+  const explicit = env.NOLO_CODEX_BIN?.trim();
+  if (explicit) return explicit;
+  const windowsAppsCodex = findWindowsAppsCodex(env);
+  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
+  return "codex";
+}
+
+export {
+  resolveLaunchableCodexCommand
+};

package/chunk-JZPBVBIY.js

@@ -0,0 +1,94 @@
+// packages/agent-runtime/oauthTokenStore.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+function getCredentialsDir(homeDir = homedir()) {
+  return join(homeDir, ".nolo", "credentials");
+}
+function getCredentialPath(provider, homeDir = homedir()) {
+  return join(getCredentialsDir(homeDir), `${provider}.json`);
+}
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+}
+function writePrivateFile(path, body) {
+  writeFileSync(path, body, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function readOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed?.provider || !parsed?.accessToken) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeOAuthCredential(provider, credential, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  ensurePrivateDir(getCredentialsDir(homeDir));
+  writePrivateFile(path, `${JSON.stringify(credential, null, 2)}
+`);
+}
+function removeOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return;
+  unlinkSync(path);
+}
+function createOAuthTokenStore(homeDir = homedir()) {
+  return {
+    read(provider) {
+      return readOAuthCredential(provider, homeDir);
+    },
+    write(provider, credential) {
+      writeOAuthCredential(provider, credential, homeDir);
+    },
+    remove(provider) {
+      removeOAuthCredential(provider, homeDir);
+    }
+  };
+}
+function isTokenExpired(credential, skewMs = DEFAULT_REFRESH_SKEW_MS, now = Date.now()) {
+  if (!credential.expiresAt) return false;
+  return credential.expiresAt - now <= skewMs;
+}
+async function resolveFreshAccessToken(args) {
+  const store = args.store ?? createOAuthTokenStore(args.homeDir);
+  const now = args.now ?? Date.now;
+  const credential = store.read(args.provider);
+  if (!credential) return null;
+  if (!args.force && !isTokenExpired(credential, args.skewMs ?? DEFAULT_REFRESH_SKEW_MS, now())) {
+    return credential.accessToken;
+  }
+  if (!credential.refreshToken || !args.refresh) return null;
+  const refreshed = await args.refresh(credential);
+  store.write(args.provider, refreshed);
+  return refreshed.accessToken;
+}
+
+export {
+  getCredentialsDir,
+  readOAuthCredential,
+  writeOAuthCredential,
+  createOAuthTokenStore,
+  isTokenExpired,
+  resolveFreshAccessToken
+};

package/chunk-KB7YFGL6.js

@@ -0,0 +1,34 @@
+import {
+  fetchReferenceContents,
+  resolveReferenceAssets
+} from "./chunk-TZNCFAUP.js";
+
+// packages/ai/agent/fetchAgentContexts.ts
+async function fetchAgentContexts(references, dispatch) {
+  if (!Array.isArray(references)) {
+    return { botInstructionsContext: "", botKnowledgeContext: "" };
+  }
+  const { references: normalizedRefs, contentByKey } = await resolveReferenceAssets(references, dispatch);
+  const instructionKeys = /* @__PURE__ */ new Set();
+  const knowledgeKeys = /* @__PURE__ */ new Set();
+  normalizedRefs.forEach((ref) => {
+    if (!ref.dbKey) return;
+    ref.type === "instruction" ? instructionKeys.add(ref.dbKey) : knowledgeKeys.add(ref.dbKey);
+  });
+  const [instructionsMap, knowledgeMap] = await Promise.all([
+    fetchReferenceContents(Array.from(instructionKeys), dispatch, {
+      preloaded: contentByKey
+    }),
+    fetchReferenceContents(Array.from(knowledgeKeys), dispatch, {
+      preloaded: contentByKey
+    })
+  ]);
+  return {
+    botInstructionsContext: Array.from(instructionsMap.values()).join(""),
+    botKnowledgeContext: Array.from(knowledgeMap.values()).join("")
+  };
+}
+
+export {
+  fetchAgentContexts
+};

package/chunk-KKY4B2Q2.js

@@ -0,0 +1,21 @@
+// packages/agent-runtime/staleReplayGuard.ts
+var wrapHistoricalSummaryWithReplayGuard = (summary) => {
+  const trimmed = summary.trim();
+  if (!trimmed) return "";
+  return [
+    "\u3010\u5386\u53F2\u53C2\u8003\uFF0C\u975E\u6D3B\u6307\u4EE4\u3011\u4EE5\u4E0B\u4E3A\u51BB\u7ED3\u6458\u8981\uFF0C\u5176\u4E2D\u7684\u4EFB\u52A1/skill/ARGUMENTS \u9ED8\u8BA4\u5DF2\u8FC7\u671F\uFF0C\u4E0D\u5F97\u91CD\u65B0\u6267\u884C\u3002",
+    trimmed
+  ].join("\n");
+};
+
+// packages/agent-runtime/memoryUseGuidance.ts
+var MEMORY_USE_GUIDANCE = `--- \u8BB0\u5FC6\u4F7F\u7528\u65B9\u5F0F ---
+- \u8BB0\u5FC6\u662F\u4E2A\u6027\u5316\u589E\u5F3A\u5C42\uFF1B\u5F53\u524D\u8F93\u5165/\u5BF9\u8BDD/\u7CFB\u7EDF\u89C4\u5219/Agent prompt/skill/\u7528\u6237\u5168\u5C40\u504F\u597D\u90FD\u4F18\u5148\u4E8E\u5B83\u3002\u5F53\u524D\u8F93\u5165\u7ED9\u51FA\u65B0\u8BED\u8A00\u3001\u6280\u672F\u6808\u3001\u6570\u503C\u3001\u7EA6\u675F\u6216\u660E\u786E\u8986\u76D6\u65E7\u504F\u597D\u65F6\uFF0C\u91C7\u7528\u5F53\u524D\u8F93\u5165\uFF0C\u4E0D\u8981\u628A\u65E7\u8BB0\u5FC6\u5F53\u66F4\u9AD8\u771F\u503C\u3002
+- \u8BB0\u5FC6\u542B\u7528\u6237\u8EAB\u4EFD/\u79F0\u547C/\u5173\u7CFB/\u957F\u671F\u504F\u597D/\u9879\u76EE\u80CC\u666F\u65F6\uFF0C\u76F8\u5173\u5904\u81EA\u7136\u4F53\u73B0\uFF08\u5F00\u573A\u79F0\u547C\u3001\u4E0A\u4E0B\u6587\u786E\u8BA4\u3001\u56DE\u7B54\u7ED3\u6784\u3001\u53D6\u820D\u6807\u51C6\uFF09\uFF0C\u4E0D\u8981\u6BCF\u53E5\u673A\u68B0\u79F0\u547C\u7528\u6237\u3002
+- \u201C\u4E0A\u6B21/\u7EE7\u7EED/\u8FD9\u4E2A\u9879\u76EE\u201D\u7B49\u6307\u4EE3\u4F18\u5148\u6309\u5F53\u524D dialog/space/project/agent/sourceDialog \u7B49 KV \u8DEF\u5F84\u548C\u65F6\u95F4\u7EBF\u5B9A\u4F4D\uFF0C\u4E0D\u8981\u53EA\u6309\u8BED\u4E49\u76F8\u4F3C\u5EA6\u635E\u4E00\u6761\u3002
+- \u63A8\u65AD\u578B\u8BB0\u5FC6\u53EA\u7528\u4E8E\u628A\u63E1\u8BED\u6C14\u3001\u72B6\u6001\u548C\u672A\u5B8C\u6210\u4E8B\u9879\uFF0C\u4E0D\u8981\u8BF4\u6210\u201C\u4F60\u660E\u786E\u544A\u8BC9\u8FC7\u6211\u201D\u6216\u5F53\u6210\u7528\u6237\u5DF2\u6388\u6743\u4FDD\u5B58\u7684\u4E8B\u5B9E\u3002\u51B2\u7A81\u6216\u573A\u666F\u4E0D\u660E\u65F6\u8BF4\u660E\u4F9D\u636E\u6216\u7B80\u77ED\u786E\u8BA4\uFF0C\u4E0D\u8981\u786C\u5957\u3002`;
+
+export {
+  wrapHistoricalSummaryWithReplayGuard,
+  MEMORY_USE_GUIDANCE
+};

package/chunk-KQHGZWSV.js

@@ -0,0 +1,63 @@
+import {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/database/userDataMerge.ts
+var getUserDataItemTimestamp = (dataItem) => getRecordTimestamp(dataItem);
+var getItemKey = (item) => {
+  const candidates = [
+    typeof item.contentKey === "string" ? item.contentKey : void 0,
+    typeof item.dbKey === "string" ? item.dbKey : void 0,
+    typeof item.appKey === "string" ? item.appKey : void 0,
+    typeof item.appId === "string" ? item.appId : void 0,
+    item.id
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var mergeAndDedupUserData = (localData, remoteResults, options = {}) => {
+  const uniqueMap = /* @__PURE__ */ new Map();
+  const mergeRecordMetadata = (currentItem, nextItem) => {
+    if (typeof currentItem.serverOrigin !== "string" && typeof nextItem.serverOrigin === "string" && nextItem.serverOrigin.trim().length > 0) {
+      return {
+        ...currentItem,
+        serverOrigin: nextItem.serverOrigin
+      };
+    }
+    return currentItem;
+  };
+  const addToMap = (item) => {
+    const itemKey = getItemKey(item);
+    if (!itemKey) return;
+    const existing = uniqueMap.get(itemKey);
+    if (!existing) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+    if (shouldReplaceWithNextRecord(item, existing)) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+    uniqueMap.set(itemKey, mergeRecordMetadata(existing, item));
+  };
+  localData.forEach(addToMap);
+  remoteResults.forEach((result) => {
+    const items = result?.data?.data;
+    if (Array.isArray(items)) {
+      items.forEach(addToMap);
+    }
+  });
+  const merged = Array.from(uniqueMap.values());
+  return options.includeDeleted ? merged : merged.filter((item) => !isTombstoneRecord(item));
+};
+
+export {
+  getUserDataItemTimestamp,
+  mergeAndDedupUserData
+};

package/chunk-KUG52IAP.js

@@ -0,0 +1,8 @@
+// packages/core/isRecord.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  isRecord
+};

package/chunk-KX6YBIHG.js

@@ -0,0 +1,8 @@
+// packages/core/recordOrEmpty.ts
+function asRecordOrEmpty(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+export {
+  asRecordOrEmpty
+};

package/chunk-LAWBMYBC.js

@@ -0,0 +1,171 @@
+import {
+  i18n_default,
+  toolRegistry
+} from "./chunk-GGUO4FKF.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-LM25IZBJ.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
+};