nolo-cli 0.96.0-alpha.1 → 0.96.0

package/{chunk-XOVEWFLK.js → chunk-G3BCMDJB.js}

@@ -1,15 +1,15 @@
 import {
   toolRegistry
-} from "./chunk-MMPXJXHT.js";
+} from "./chunk-VKEMMN62.js";
 import {
-  i18n_default
-} from "./chunk-FOWEGIMF.js";
+  runtime_default
+} from "./chunk-5G7QSEFG.js";
 import {
   canonicalizeToolNames
-} from "./chunk-O6OSWFZQ.js";
+} from "./chunk-XUWRURDF.js";
 import {
   isNoloHostedProvider
-} from "./chunk-Q67DOFOO.js";
+} from "./chunk-Y3PMXGLH.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -17,94 +17,6 @@ import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 
-// packages/ai/chat/inlineImageUrlsForCustomProvider.ts
-var FILE_CONTENT_PATH = "/api/v1/db/file/content/";
-var shouldInlineImageUrlsForAgent = (agentConfig) => {
-  const apiSource = agentConfig?.apiSource?.toLowerCase();
-  const provider = agentConfig?.provider?.toLowerCase();
-  const model = agentConfig?.model?.toLowerCase();
-  if (apiSource === "custom" || provider === "custom") return true;
-  if (isNoloHostedProvider(provider)) return true;
-  return provider === "openrouter" && model === "minimax/minimax-m3";
-};
-var isInlineCandidate = (url) => /^https?:\/\//i.test(url) && url.includes(FILE_CONTENT_PATH);
-var bytesToBase64 = (bytes) => {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary);
-};
-var defaultFetchImage = async (url) => {
-  const response = await fetch(url);
-  if (!response.ok) {
-    return {
-      ok: false,
-      error: `HTTP ${response.status}`
-    };
-  }
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  return {
-    ok: true,
-    mimeType: response.headers.get("content-type") ?? "application/octet-stream",
-    bytes
-  };
-};
-var cloneImagePartWithDataUrl = async (part, fetchImage, isAllowedImageUrl) => {
-  const url = part?.image_url?.url;
-  if (typeof url !== "string" || !isInlineCandidate(url) || isAllowedImageUrl && !isAllowedImageUrl(url)) {
-    return part;
-  }
-  const result = await fetchImage(url);
-  if (!result.ok || !result.bytes) return part;
-  const mimeType = result.mimeType || "application/octet-stream";
-  return {
-    ...part,
-    image_url: {
-      ...part.image_url,
-      url: `data:${mimeType};base64,${bytesToBase64(result.bytes)}`
-    }
-  };
-};
-var inlineImageUrlsForCustomProvider = async (bodyData, options) => {
-  if (!options.shouldInline) return bodyData;
-  const body = bodyData;
-  if (!Array.isArray(body?.messages)) return bodyData;
-  const fetchImage = options.fetchImage ?? defaultFetchImage;
-  let changed = false;
-  const messages = [];
-  for (const message of body.messages) {
-    if (!Array.isArray(message?.content)) {
-      messages.push(message);
-      continue;
-    }
-    const content = await Promise.all(
-      message.content.map(async (part) => {
-        if (part?.type !== "image_url") return part;
-        return cloneImagePartWithDataUrl(
-          part,
-          fetchImage,
-          options.isAllowedImageUrl
-        );
-      })
-    );
-    let messageChanged = false;
-    for (let i = 0; i < content.length; i++) {
-      if (content[i] !== message.content[i]) {
-        changed = true;
-        messageChanged = true;
-        break;
-      }
-    }
-    messages.push(messageChanged ? { ...message, content } : message);
-  }
-  if (!changed) return bodyData;
-  return {
-    ...body,
-    messages
-  };
-};
-
 // packages/ai/tools/toolSchemaCompatibility.ts
 var COMPOSITION_KEYS = ["anyOf", "oneOf", "allOf"];
 var LIMITED_JSON_SCHEMA_PROVIDERS = /* @__PURE__ */ new Set([
@@ -151,12 +63,12 @@ var PREPARE_TOOLS_CACHE_LIMIT = 128;
 var warnedUnknownToolNames = /* @__PURE__ */ new Set();
 function getTranslation(keys, defaultVal) {
   for (const key of keys) {
-    if (i18n_default.exists(key)) {
-      return i18n_default.t(key);
+    if (runtime_default.exists(key)) {
+      return runtime_default.t(key);
     }
     const aiKey = key.startsWith("ai:") ? key : `ai:${key}`;
-    if (i18n_default.exists(aiKey)) {
-      return i18n_default.t(aiKey);
+    if (runtime_default.exists(aiKey)) {
+      return runtime_default.t(aiKey);
     }
   }
   return defaultVal;
@@ -203,7 +115,7 @@ function translateSchema(schema) {
   return nextSchema;
 }
 function currentI18nLanguage() {
-  return typeof i18n_default.language === "string" ? i18n_default.language : "";
+  return typeof runtime_default.language === "string" ? runtime_default.language : "";
 }
 function translateSchemaCached(schema) {
   if (!schema || typeof schema !== "object") return schema;
@@ -268,8 +180,96 @@ var prepareTools = (toolNames, options) => {
   return prepared.slice();
 };
 
+// packages/ai/chat/inlineImageUrlsForCustomProvider.ts
+var FILE_CONTENT_PATH = "/api/v1/db/file/content/";
+var shouldInlineImageUrlsForAgent = (agentConfig) => {
+  const apiSource = agentConfig?.apiSource?.toLowerCase();
+  const provider = agentConfig?.provider?.toLowerCase();
+  const model = agentConfig?.model?.toLowerCase();
+  if (apiSource === "custom" || provider === "custom") return true;
+  if (isNoloHostedProvider(provider)) return true;
+  return provider === "openrouter" && model === "minimax/minimax-m3";
+};
+var isInlineCandidate = (url) => /^https?:\/\//i.test(url) && url.includes(FILE_CONTENT_PATH);
+var bytesToBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+var defaultFetchImage = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    return {
+      ok: false,
+      error: `HTTP ${response.status}`
+    };
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  return {
+    ok: true,
+    mimeType: response.headers.get("content-type") ?? "application/octet-stream",
+    bytes
+  };
+};
+var cloneImagePartWithDataUrl = async (part, fetchImage, isAllowedImageUrl) => {
+  const url = part?.image_url?.url;
+  if (typeof url !== "string" || !isInlineCandidate(url) || isAllowedImageUrl && !isAllowedImageUrl(url)) {
+    return part;
+  }
+  const result = await fetchImage(url);
+  if (!result.ok || !result.bytes) return part;
+  const mimeType = result.mimeType || "application/octet-stream";
+  return {
+    ...part,
+    image_url: {
+      ...part.image_url,
+      url: `data:${mimeType};base64,${bytesToBase64(result.bytes)}`
+    }
+  };
+};
+var inlineImageUrlsForCustomProvider = async (bodyData, options) => {
+  if (!options.shouldInline) return bodyData;
+  const body = bodyData;
+  if (!Array.isArray(body?.messages)) return bodyData;
+  const fetchImage = options.fetchImage ?? defaultFetchImage;
+  let changed = false;
+  const messages = [];
+  for (const message of body.messages) {
+    if (!Array.isArray(message?.content)) {
+      messages.push(message);
+      continue;
+    }
+    const content = await Promise.all(
+      message.content.map(async (part) => {
+        if (part?.type !== "image_url") return part;
+        return cloneImagePartWithDataUrl(
+          part,
+          fetchImage,
+          options.isAllowedImageUrl
+        );
+      })
+    );
+    let messageChanged = false;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] !== message.content[i]) {
+        changed = true;
+        messageChanged = true;
+        break;
+      }
+    }
+    messages.push(messageChanged ? { ...message, content } : message);
+  }
+  if (!changed) return bodyData;
+  return {
+    ...body,
+    messages
+  };
+};
+
 export {
+  prepareTools,
   shouldInlineImageUrlsForAgent,
-  inlineImageUrlsForCustomProvider,
-  prepareTools
+  inlineImageUrlsForCustomProvider
 };

package/chunk-GMZLP5DV.js

@@ -0,0 +1,82 @@
+// packages/agent-runtime/sseFrames.ts
+async function* readSseFrames(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("SSE response did not include a readable body.");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let boundary = findSseFrameBoundary(buffer);
+    while (boundary) {
+      yield buffer.slice(0, boundary.index);
+      buffer = buffer.slice(boundary.index + boundary.separatorLength);
+      boundary = findSseFrameBoundary(buffer);
+    }
+  }
+  const remaining = decoder.decode();
+  if (remaining) {
+    buffer += remaining;
+    let boundary = findSseFrameBoundary(buffer);
+    while (boundary) {
+      yield buffer.slice(0, boundary.index);
+      buffer = buffer.slice(boundary.index + boundary.separatorLength);
+      boundary = findSseFrameBoundary(buffer);
+    }
+  }
+  if (buffer.trim()) yield buffer;
+}
+function findSseFrameBoundary(buffer) {
+  const lfLf = buffer.indexOf("\n\n");
+  const crLfCrLf = buffer.indexOf("\r\n\r\n");
+  if (lfLf === -1 && crLfCrLf === -1) return null;
+  const useLf = lfLf !== -1 && (crLfCrLf === -1 || lfLf < crLfCrLf);
+  return useLf ? { index: lfLf, separatorLength: 2 } : { index: crLfCrLf, separatorLength: 4 };
+}
+async function* streamSseDataValues(response, parse) {
+  const reader = response.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const parsed = parse(line);
+      if (parsed) yield parsed;
+    }
+  }
+  const remaining = decoder.decode();
+  if (remaining) {
+    buffer += remaining;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const parsed = parse(line);
+      if (parsed) yield parsed;
+    }
+  }
+  if (buffer.trim()) {
+    const parsed = parse(buffer);
+    if (parsed) yield parsed;
+  }
+}
+async function readSseDataValues(response, parse) {
+  const values = [];
+  for await (const value of streamSseDataValues(response, parse)) {
+    values.push(value);
+  }
+  return values;
+}
+
+export {
+  readSseFrames,
+  streamSseDataValues,
+  readSseDataValues
+};

package/{chunk-FDTR4QJ6.js → chunk-H6A6X4EK.js}

@@ -180,6 +180,36 @@ function resolveCooldownGate(input, now) {
   }
   return now - lastProbeAt >= PROBE_INTERVAL_MS ? "probe" : "blocked";
 }
+function resolveCredentialKey(agent) {
+  if (!agent || typeof agent !== "object") return void 0;
+  for (const field of ["apiKeyRef", "credentialRef"]) {
+    const value = agent[field];
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return void 0;
+}
+function resolveCredentialKeyWithFallback(agent) {
+  const byRef = resolveCredentialKey(agent);
+  if (byRef) return byRef;
+  if (!agent || typeof agent !== "object") return void 0;
+  const endpoint = agent.customProviderUrl;
+  if (typeof endpoint === "string") {
+    const trimmed = endpoint.trim();
+    if (trimmed) {
+      try {
+        const origin = new URL(trimmed).origin;
+        if (origin && origin !== "null") return `custom-endpoint:${origin}`;
+      } catch {
+      }
+    }
+  }
+  const key = agent.key;
+  if (typeof key === "string" && key.trim()) return `custom-agent:${key.trim()}`;
+  return void 0;
+}
 
 export {
   QUOTA_ERROR_PATTERNS,
@@ -188,5 +218,6 @@ export {
   isQuotaLimited403Body,
   resolveAvailabilityAction,
   mergeAvailabilityDeadline,
-  resolveCooldownGate
+  resolveCooldownGate,
+  resolveCredentialKeyWithFallback
 };

package/{chunk-DVINR3PL.js → chunk-HDLLCBRF.js}

@@ -1,7 +1,7 @@
 import {
   MEMORY_USE_GUIDANCE,
   wrapHistoricalSummaryWithReplayGuard
-} from "./chunk-2GRGFCF6.js";
+} from "./chunk-4VJAC32I.js";
 
 // packages/agent-runtime/turnContext.ts
 var DEFAULT_RECENT_CONTENT_LIMIT = 10;

package/{chunk-ONXOABJR.js → chunk-HNGRBWYF.js}

@@ -206,9 +206,12 @@ export {
   resolveNoloStateDir,
   getLegacyCredentialPath,
   migrateLegacyCredentialFile,
+  DEFAULT_REFRESH_SKEW_MS,
   getCredentialsDir,
+  getCredentialPath,
   readOAuthCredential,
   writeOAuthCredential,
+  removeOAuthCredential,
   createOAuthTokenStore,
   isTokenExpired,
   resolveFreshAccessToken

package/{chunk-IAO6JBYW.js → chunk-HP2HV7RZ.js}

@@ -1,23 +1,30 @@
+import {
+  isSubscriptionEndpoint,
+  isSubscriptionOAuthCredential
+} from "./chunk-DAWDCRIG.js";
 import {
   isOAuthApiKeyRef
 } from "./chunk-YYLHWIW6.js";
 import {
   compareAgentSelection
-} from "./chunk-IIVGDG4I.js";
+} from "./chunk-LNPYTNMG.js";
+import {
+  isAgentUnavailableNow
+} from "./chunk-H6A6X4EK.js";
 import {
   isAntigravityOAuthAgent
-} from "./chunk-UZGQNTVW.js";
+} from "./chunk-S5XGT6GB.js";
 import {
   getModelAbility
-} from "./chunk-ACTMNVHM.js";
+} from "./chunk-CYSYR67N.js";
+import {
+  fnv1a32Hex
+} from "./chunk-WIWM4FE3.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,
@@ -356,12 +385,13 @@ function toSafeAgentSummary(record, options) {
   const isPublic = record?.isPublic === true || record?.isPublicFlag === true || record?.publicRecordExists === true;
   const updatedAt = safeTimestamp(record?.updatedAt ?? record?.createdAt ?? record?.created);
   const nextAvailableAt = typeof record?.nextAvailableAt === "number" && Number.isFinite(record.nextAvailableAt) ? record.nextAvailableAt : void 0;
+  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,
@@ -418,8 +448,12 @@ function toSafeAgentSummary(record, options) {
     isOwned,
     isOAuth,
     ...nextAvailableAt !== void 0 ? { nextAvailableAt } : {},
+    ...quota !== void 0 ? { quota } : {},
     ...credentialGroup !== void 0 ? { credentialGroup } : {},
     ...credentialKind !== void 0 ? { credentialKind } : {},
+    // 「未知 ≠ 独立」：无 credentialGroup 时显式 credentialed:false，调用方
+    // 不得把缺失解读成独立凭证（并发扇出守卫依赖这个区分）。
+    credentialed: credentialGroup !== void 0,
     updatedAt
   };
 }
@@ -445,8 +479,11 @@ var COMPACT_AGENT_SUMMARY_FIELDS = [
   // 决策信息（CLI --show-unavailable 场景）；默认列表已把这类 agent 过滤掉，
   // 所以通常根本不占字节。
   "nextAvailableAt",
+  // 额度快照：只有上游真上报过窗口的 agent 才带（通常是小对象）。
+  "quota",
   "credentialGroup",
-  "credentialKind"
+  "credentialKind",
+  "credentialed"
 ];
 function omitNullishAgentSummaryFields(summary) {
   const result = {};
@@ -477,6 +514,7 @@ var UNAVAILABLE_AGENT_SUMMARY_FIELDS = [
   "isOAuth",
   "isOwned",
   "nextAvailableAt",
+  "quota",
   "favoritedAt",
   "updatedAt"
 ];
@@ -496,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
 };