nolo-cli 0.8.0-alpha.6 → 0.8.0-alpha.7

package/chunk-2LMT6K6N.js

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

package/chunk-2MALU52L.js

@@ -0,0 +1,51 @@
+import {
+  trimTrailingSlash
+} from "./chunk-XDVAYP26.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/antigravityOAuth.ts
+var ANTIGRAVITY_CLOUD_CODE_BASE_URL = "https://daily-cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_CLOUD_CODE_HOST = "cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_LEGACY_GENERIC_BASE_RE = /^https?:\/\/cloudcode-pa\.googleapis\.com$/i;
+function getAntigravityUserAgent() {
+  const version = process.env.NOLO_ANTIGRAVITY_VERSION || "2.1.4";
+  const os = process.platform === "win32" ? "windows" : process.platform;
+  const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch;
+  return `antigravity/hub/${version} ${os}/${arch}`;
+}
+function resolveAntigravityCloudCodeBaseUrl(customProviderUrl) {
+  const raw = (customProviderUrl ?? "").trim();
+  if (!raw) return ANTIGRAVITY_CLOUD_CODE_BASE_URL;
+  const trimmed = trimTrailingSlash(raw);
+  if (trimmed.includes(ANTIGRAVITY_CLOUD_CODE_HOST)) {
+    const base = trimmed.replace(/\/v1internal:.*$/i, "").replace(/\/$/, "");
+    if (ANTIGRAVITY_LEGACY_GENERIC_BASE_RE.test(base)) {
+      return ANTIGRAVITY_CLOUD_CODE_BASE_URL;
+    }
+    return base;
+  }
+  return ANTIGRAVITY_CLOUD_CODE_BASE_URL;
+}
+function isAntigravityOAuthAgent(agentConfig) {
+  if (!agentConfig) return false;
+  const apiKeyRef = asTrimmedLowercaseString(agentConfig.apiKeyRef);
+  const provider = asTrimmedLowercaseString(agentConfig.provider);
+  const url = asTrimmedLowercaseString(agentConfig.customProviderUrl);
+  return apiKeyRef === "antigravity" || provider === "google-antigravity" || url.includes(ANTIGRAVITY_CLOUD_CODE_HOST);
+}
+function readAntigravityProjectId(metadata) {
+  return asOptionalTrimmedString(metadata?.projectId);
+}
+
+export {
+  ANTIGRAVITY_CLOUD_CODE_BASE_URL,
+  getAntigravityUserAgent,
+  resolveAntigravityCloudCodeBaseUrl,
+  isAntigravityOAuthAgent,
+  readAntigravityProjectId
+};

package/chunk-364VYAX2.js

@@ -0,0 +1,19 @@
+import {
+  buildAgentRuntimeAgentLookupKeys,
+  shouldFetchAgentRuntimeRecordRemotely
+} from "./chunk-5XH3NZ4T.js";
+
+// packages/cli/client/localAgentRecords.ts
+var buildLocalAgentLookupKeys = buildAgentRuntimeAgentLookupKeys;
+var shouldReadAgentKeyRemotely = shouldFetchAgentRuntimeRecordRemotely;
+
+// packages/core/agentHandle.ts
+function normalizeAgentHandle(value) {
+  return typeof value === "string" && value.trim() ? value.trim().toLowerCase().replace(/\s+/g, " ") : void 0;
+}
+
+export {
+  buildLocalAgentLookupKeys,
+  shouldReadAgentKeyRemotely,
+  normalizeAgentHandle
+};