nolo-cli 0.103.0-alpha.2 → 0.103.0

package/chunk-OCZKATRC.js

@@ -0,0 +1,129 @@
+// packages/ai/chat/parseApiError.ts
+var CONTEXT_OVERFLOW_ACTIONS = [
+  "compact-and-retry",
+  "new-dialog",
+  "switch-model",
+  "retry"
+];
+var CONTEXT_TOO_LARGE_ACTIONS = [
+  "new-dialog",
+  "switch-model",
+  "retry"
+];
+var truncateErrorMessage = (message, maxChars = 320) => message.length <= maxChars ? message : `${message.slice(0, maxChars)}\u2026`;
+var isContextOverflowText = (message) => /maximum context|context (length|window|overflow|limit)|context_length_exceed\w*|requested about .*tokens|too many tokens|prompt is too long|exceeds? (the )?(model|max)/i.test(
+  message
+);
+function classifyApiError(input) {
+  const { status, message, body, code } = input;
+  const errorMessage = message;
+  let defaultMessage = `\u72B6\u6001\u7801 ${status} ${input.statusText ?? ""}`;
+  switch (status) {
+    case 400:
+      if (isContextOverflowText(errorMessage) || isContextOverflowText(body) || code === "UPSTREAM_400") {
+        return {
+          kind: "context_overflow",
+          message: "\u4E0A\u4E0B\u6587\u8FC7\u957F\uFF1A\u672C\u8F6E\u6D88\u606F\u6216\u5DE5\u5177\u7ED3\u679C\u592A\u5927\u3002\u8BF7\u7F29\u5C0F\u8303\u56F4\uFF0C\u6216\u5148\u8BFB\u53D6\u66F4\u5C0F\u7247\u6BB5\u540E\u518D\u7EE7\u7EED\u3002",
+          code,
+          status,
+          retryable: true,
+          actions: [...CONTEXT_OVERFLOW_ACTIONS]
+        };
+      }
+      if (code === "MISSING_PROVIDER_API_KEY") {
+        return {
+          kind: "generic",
+          message: truncateErrorMessage(errorMessage),
+          code,
+          status,
+          retryable: false
+        };
+      }
+      if (errorMessage && errorMessage !== defaultMessage) {
+        return {
+          kind: "generic",
+          message: `\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF: ${truncateErrorMessage(errorMessage)}`,
+          code,
+          status,
+          retryable: false
+        };
+      }
+      return { kind: "generic", message: "\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u8F93\u5165", code, status, retryable: false };
+    case 413:
+      return {
+        kind: "context_too_large",
+        message: "\u8BF7\u6C42\u5185\u5BB9\u8FC7\u5927\uFF1A\u8BF7\u51CF\u5C11\u4E00\u6B21\u53D1\u9001\u7684\u6D88\u606F\u3001\u6587\u4EF6\u6216\u5DE5\u5177\u7ED3\u679C\u3002",
+        code,
+        status,
+        retryable: true,
+        actions: [...CONTEXT_TOO_LARGE_ACTIONS]
+      };
+    case 401:
+      return {
+        kind: "auth",
+        message: code === "AUTH_TOKEN_EXPIRED" ? "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55" : code === "AUTH_ACCOUNT_INVALID" ? "\u8D26\u6237\u65E0\u6548\u6216\u5DF2\u88AB\u505C\u7528\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458" : code === "AUTH_NO_TOKEN" ? "\u672A\u68C0\u6D4B\u5230\u767B\u5F55\u72B6\u6001\uFF0C\u8BF7\u5148\u767B\u5F55" : code === "AUTH_INVALID_TOKEN" ? "\u767B\u5F55\u51ED\u8BC1\u65E0\u6548\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55" : code === "AUTH_TOKEN_NOT_ACTIVE" ? "\u4EE4\u724C\u5C1A\u672A\u751F\u6548\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" : errorMessage && errorMessage !== `\u72B6\u6001\u7801 401 Unauthorized` ? `\u8BA4\u8BC1\u9519\u8BEF: ${truncateErrorMessage(errorMessage)}` : "\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u5148\u767B\u51FA\u540E\u91CD\u65B0\u767B\u5F55",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    case 503:
+      return {
+        kind: "server",
+        message: errorMessage && errorMessage !== `\u72B6\u6001\u7801 503 Service Unavailable` ? truncateErrorMessage(errorMessage) : "\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    case 504:
+      return {
+        kind: "timeout",
+        message: "\u8BF7\u6C42\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+    default:
+      return {
+        kind: "generic",
+        message: `API\u8BF7\u6C42\u5931\u8D25: ${truncateErrorMessage(errorMessage)}`,
+        code,
+        status,
+        retryable: true,
+        actions: ["retry"]
+      };
+  }
+}
+async function parseApiErrorInfo(response) {
+  const errorBody = await response.text();
+  let errorMessage = `\u72B6\u6001\u7801 ${response.status} ${response.statusText}`;
+  let errorCode = `E${response.status}`;
+  try {
+    const errorJson = JSON.parse(errorBody);
+    errorMessage = errorJson?.error?.message || errorJson?.message || errorJson?.msg || errorBody || errorMessage;
+    errorCode = errorJson?.error?.code || errorJson?.code || errorCode;
+  } catch (_e) {
+    if (errorBody) {
+      errorMessage = errorBody;
+    }
+  }
+  return classifyApiError({
+    status: response.status,
+    statusText: response.statusText,
+    message: errorMessage,
+    body: errorBody,
+    code: errorCode
+  });
+}
+async function parseApiError(response) {
+  return (await parseApiErrorInfo(response)).message;
+}
+
+export {
+  CONTEXT_OVERFLOW_ACTIONS,
+  CONTEXT_TOO_LARGE_ACTIONS,
+  isContextOverflowText,
+  parseApiError
+};

package/{chunk-PQFHGD77.js → chunk-OM2RUOEU.js}

@@ -1,23 +1,30 @@
 import {
   isOAuthApiKeyRef
-} from "./chunk-YYLHWIW6.js";
+} from "./chunk-UKZX3NHN.js";
 import {
   compareAgentSelection
-} from "./chunk-IIVGDG4I.js";
+} from "./chunk-7KWFIKKK.js";
+import {
+  isAgentUnavailableNow
+} from "./chunk-H6A6X4EK.js";
+import {
+  isSubscriptionEndpoint,
+  isSubscriptionOAuthCredential
+} from "./chunk-EKPKW6RM.js";
 import {
   isAntigravityOAuthAgent
-} from "./chunk-UZGQNTVW.js";
+} from "./chunk-UA324D4O.js";
 import {
   getModelAbility
-} from "./chunk-ACTMNVHM.js";
+} from "./chunk-CYSYR67N.js";
+import {
+  fnv1a32Hex
+} from "./chunk-O7SVKKLY.js";
 import {
   isOwnedAgentKey,
   ownedAgentKey,
   publicAgentKey
 } from "./chunk-M2EJHDJP.js";
-import {
-  fnv1a32Hex
-} from "./chunk-UKWGR5SS.js";
 
 // packages/ai/agent/agentBilling.ts
 function resolveBillingSource(candidate) {
@@ -36,6 +43,9 @@ function resolveBillingSource(candidate) {
   }
   if (candidate?.isOAuth === true || candidate?.billingSource === "user_subscription" || candidate?.apiSource === "oauth" || isOAuthApiKeyRef(candidate?.apiKeyRef)) return "user_subscription";
   if (candidate?.apiSource === "custom" || candidate?.billingSource === "user_api") {
+    if (isSubscriptionEndpoint(candidate?.customProviderUrl) || isSubscriptionOAuthCredential(candidate?.apiKeyRef)) {
+      return "user_subscription";
+    }
     return "user_api";
   }
   return "platform_credits";
@@ -227,6 +237,16 @@ function deriveCredentialGroup(ref) {
     credentialKind: "api-key"
   };
 }
+function deriveCustomProviderCredentialGroup(userId, customProviderUrl) {
+  if (typeof customProviderUrl !== "string" || !customProviderUrl.trim()) {
+    return void 0;
+  }
+  const basis = `${userId ?? ""}|${customProviderUrl.trim().toLowerCase()}`;
+  return {
+    credentialGroup: `custom-${fnv1a32Hex(basis)}`,
+    credentialKind: "api-key"
+  };
+}
 function summarizeCredentialGroups(agents, now = Date.now()) {
   const groups = /* @__PURE__ */ new Map();
   for (const agent of agents) {
@@ -327,6 +347,15 @@ function resolveFavoriteStatus(record, options) {
   }
   return { isFavorite: false, favoritedAt: null };
 }
+function isOwnedAgentRecord(record, userId) {
+  if (!userId) return false;
+  if (typeof record?.userId === "string" && record.userId === userId || typeof record?.ownerId === "string" && record.ownerId === userId) {
+    return true;
+  }
+  return [record?.dbKey, record?.privateKey].some(
+    (key) => isOwnedAgentKey(key, userId)
+  );
+}
 function toSafeAgentSummary(record, options) {
   const rawId = parseAgentRecordId(
     typeof record?.privateKey === "string" ? record.privateKey : record?.dbKey,
@@ -359,11 +388,10 @@ function toSafeAgentSummary(record, options) {
   const rawQuota = record?.quota;
   const quota = rawQuota && typeof rawQuota === "object" && Array.isArray(rawQuota.windows) && typeof rawQuota.observedAt === "number" && Number.isFinite(rawQuota.observedAt) ? rawQuota : void 0;
   const currentUserId = options?.userId;
-  const isOwnedByRecord = Boolean(currentUserId) && (typeof record?.userId === "string" && record.userId === currentUserId || typeof record?.ownerId === "string" && record.ownerId === currentUserId);
   const ownedKey = currentUserId ? [record?.dbKey, record?.privateKey].find(
     (key) => isOwnedAgentKey(key, currentUserId)
   ) : void 0;
-  const isOwned = isOwnedByRecord || Boolean(ownedKey);
+  const isOwned = isOwnedAgentRecord(record, currentUserId);
   const isOAuth = isOAuthApiKeyRef(record?.apiKeyRef);
   const billingSource = resolveBillingSource({
     ...record,
@@ -506,12 +534,131 @@ function toUnavailableAgentSummary(summary) {
   return item;
 }
 
+// packages/ai/agent/agentDiscovery.ts
+function isPreferredAgent(agent) {
+  return agent.isFavorite === true || agent.isOwned === true || agent.isOAuth === true || agent.billingSource === "user_subscription" || agent.billingSource === "user_api" || agent.billingSource === "local";
+}
+function isPublicDiscoveryAgent(agent) {
+  return agent.isPublic === true && !isPreferredAgent(agent);
+}
+function resolveDiscoveryScope(args) {
+  const rawScope = typeof args?.scope === "string" ? args.scope.trim().toLowerCase() : void 0;
+  const hasScope = rawScope !== void 0 && rawScope !== "";
+  const hasPublicOnly = typeof args?.publicOnly === "boolean";
+  const publicOnly = args?.publicOnly === true;
+  if (hasScope) {
+    if (rawScope !== "preferred" && rawScope !== "public" && rawScope !== "all") {
+      throw new Error(`Invalid scope '${args?.scope}': must be 'preferred', 'public', or 'all'.`);
+    }
+    const scope = rawScope;
+    if (hasPublicOnly) {
+      if (publicOnly && scope !== "public") {
+        throw new Error(
+          `Conflicting arguments: scope='${args?.scope}' conflicts with publicOnly=true.`
+        );
+      }
+      if (!publicOnly && scope === "public") {
+        throw new Error(
+          `Conflicting arguments: scope='${args?.scope}' conflicts with publicOnly=false.`
+        );
+      }
+    }
+    return scope;
+  }
+  if (hasPublicOnly && publicOnly) {
+    return "public";
+  }
+  return "preferred";
+}
+function agentIdentityKeys(agent) {
+  return [agent.agentKey, agent.publicKey, agent.id].filter(
+    (key) => typeof key === "string" && key.length > 0
+  );
+}
+function deduplicateAgentSummaries(agents) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    const keys = agentIdentityKeys(agent);
+    const existing = keys.map((key) => byIdentity.get(key)).find(Boolean);
+    if (!existing) {
+      for (const key of keys) byIdentity.set(key, agent);
+      continue;
+    }
+    const winner = isPreferredAgent(agent) && !isPreferredAgent(existing) ? agent : existing;
+    for (const key of /* @__PURE__ */ new Set([...agentIdentityKeys(existing), ...keys])) byIdentity.set(key, winner);
+  }
+  return [...new Set(byIdentity.values())];
+}
+function filterAgentsByScope(agents, scope) {
+  const unique = deduplicateAgentSummaries(agents);
+  if (scope === "preferred") return unique.filter((agent) => isPreferredAgent(agent));
+  if (scope === "public") return unique.filter((agent) => isPublicDiscoveryAgent(agent));
+  return unique.filter((agent) => isPreferredAgent(agent) || agent.isPublic === true);
+}
+function matchesAgentQuery(agent, query) {
+  if (!query || typeof query !== "string") return true;
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const candidates = [
+    agent.name,
+    agent.model,
+    agent.provider,
+    agent.handle,
+    agent.agentKey,
+    agent.publicKey,
+    agent.id
+  ];
+  return candidates.some((text) => typeof text === "string" && text.toLowerCase().includes(q));
+}
+function buildAgentDiscoveryResult(options) {
+  const scope = resolveDiscoveryScope({
+    scope: options.scope,
+    publicOnly: options.publicOnly
+  });
+  const now = options.now ?? Date.now();
+  let scopedAgents = filterAgentsByScope(options.agents, scope);
+  if (options.query && typeof options.query === "string" && options.query.trim()) {
+    scopedAgents = scopedAgents.filter((a) => matchesAgentQuery(a, options.query));
+  }
+  const unavailableList = scopedAgents.filter((a) => isAgentUnavailableNow(a, now));
+  const unavailableCount = unavailableList.length;
+  const unavailableAgents = sortSafeAgentSummaries(unavailableList).map(toUnavailableAgentSummary);
+  const credentialGroups = summarizeCredentialGroups(scopedAgents, now);
+  if (options.showUnavailable !== true) {
+    scopedAgents = scopedAgents.filter((a) => !isAgentUnavailableNow(a, now));
+  }
+  const sortedAgents = sortSafeAgentSummaries(scopedAgents);
+  const projectedAgents = options.verbose === true ? sortedAgents.map(omitNullishAgentSummaryFields) : sortedAgents.map(toCompactAgentSummary);
+  return {
+    total: projectedAgents.length,
+    unavailableCount,
+    unavailableAgents,
+    credentialGroups,
+    agents: projectedAgents
+  };
+}
+function toDiscoverySafeAgentSummary(record, options) {
+  const mergedOptions = record?.publicRecordExists === true ? { ...options, publicRecordExists: true } : options;
+  return toSafeAgentSummary(record, mergedOptions);
+}
+function assembleAgentDiscoveryResult(options) {
+  const { records, summaryOptions, ...discoveryOptions } = options;
+  const agents = records.map(
+    (record) => toDiscoverySafeAgentSummary(
+      record,
+      typeof summaryOptions === "function" ? summaryOptions(record) : summaryOptions
+    )
+  );
+  return buildAgentDiscoveryResult({ ...discoveryOptions, agents });
+}
+
 export {
   deriveCredentialGroup,
+  deriveCustomProviderCredentialGroup,
   summarizeCredentialGroups,
-  toSafeAgentSummary,
-  sortSafeAgentSummaries,
-  omitNullishAgentSummaryFields,
-  toCompactAgentSummary,
-  toUnavailableAgentSummary
+  resolveDiscoveryScope,
+  matchesAgentQuery,
+  buildAgentDiscoveryResult,
+  toDiscoverySafeAgentSummary,
+  assembleAgentDiscoveryResult
 };

package/{chunk-KQHGZWSV.js → chunk-OXME3PEE.js}

@@ -2,7 +2,7 @@ import {
   getRecordTimestamp,
   isTombstoneRecord,
   shouldReplaceWithNextRecord
-} from "./chunk-GBRG75BQ.js";
+} from "./chunk-D2MDMY2M.js";
 
 // packages/database/userDataMerge.ts
 var getUserDataItemTimestamp = (dataItem) => getRecordTimestamp(dataItem);