nolo-cli 0.108.0-alpha.2 → 0.108.1

package/agentListCommands-QNUAN3YH.js

@@ -0,0 +1,800 @@
+import {
+  decorateAgentsWithPublicStatusAcrossServers,
+  formatQuotaSummary,
+  listFavoriteAgentIdsAcrossServers,
+  listLocalCachedAgents,
+  listRemoteAgents,
+  listRemoteAgentsAcrossServers,
+  listRemotePublicAgents,
+  normalizeListedAgent,
+  parseAgentListArgs
+} from "./chunk-UIYVU3S4.js";
+import {
+  refreshSubscriptionQuotas
+} from "./chunk-U4STABYN.js";
+import {
+  getReadableCliDb
+} from "./chunk-V6WXGTUJ.js";
+import {
+  buildSpaceLookup,
+  getSpaceContentKeys
+} from "./chunk-ID4G2MAR.js";
+import {
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-726TCFLQ.js";
+import {
+  queryUserRecords,
+  readDbRecord
+} from "./chunk-A337PRRR.js";
+import {
+  applyCredentialAvailability,
+  clearCredentialAvailabilityIfMarkedAt,
+  readCredentialAvailability,
+  readCredentialEntry
+} from "./chunk-6MXDOUMH.js";
+import {
+  t
+} from "./chunk-6CCAXGFK.js";
+import "./chunk-PHHFVGOJ.js";
+import "./chunk-NBTY7YJF.js";
+import {
+  buildAgentDiscoveryResult,
+  matchesAgentQuery,
+  summarizeCredentialGroups,
+  toDiscoverySafeAgentSummary
+} from "./chunk-XRXYRHE5.js";
+import "./chunk-OXME3PEE.js";
+import "./chunk-UKZX3NHN.js";
+import "./chunk-UEILX4EV.js";
+import "./chunk-D2MDMY2M.js";
+import "./chunk-NLEJWKF5.js";
+import "./chunk-3SK3J3IF.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-IFALJPEX.js";
+import "./chunk-GMZLP5DV.js";
+import "./chunk-CHOZJMJS.js";
+import "./chunk-G23MQWLJ.js";
+import "./chunk-5ZUL4CUO.js";
+import "./chunk-JJM3WS6W.js";
+import "./chunk-G6OOUQWJ.js";
+import "./chunk-56GBUMO5.js";
+import "./chunk-WJZOQR2J.js";
+import "./chunk-LAVSW2C2.js";
+import "./chunk-SJ3QFSQS.js";
+import "./chunk-QLQ573SU.js";
+import {
+  isAgentUnavailableNow,
+  resolveCredentialKeyWithFallback,
+  shouldClearCooldownFromQuota
+} from "./chunk-3MZAGMYY.js";
+import "./chunk-2MBTWINN.js";
+import "./chunk-VSPO4S33.js";
+import {
+  normalizeTimingMs
+} from "./chunk-FWY6BHIJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-PWRS2SU2.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-7DPNBQSV.js";
+import "./chunk-IHPDK6UD.js";
+import "./chunk-LWLNLZC5.js";
+import "./chunk-3LI5UCTU.js";
+import "./chunk-M2EJHDJP.js";
+import {
+  createKey,
+  createTokenKey
+} from "./chunk-RLRYVSCD.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-MW533QT3.js";
+import "./chunk-TSBCYK5F.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-PSCNXBYA.js";
+import "./chunk-KY6GPQ7O.js";
+import "./chunk-NN4UUYGB.js";
+import "./chunk-CGEK73JN.js";
+import "./chunk-W7XHHYWM.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-3EUW3WEO.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  resolveNoloHome
+} from "./chunk-GLKOYSRU.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-A7GB5UGH.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-Y6ROFCZO.js";
+import {
+  getModelAbility
+} from "./chunk-P3SFAHIL.js";
+import "./chunk-SZC4REES.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ZWQUWF6W.js";
+import "./chunk-VEA7H5FG.js";
+import "./chunk-4VJAC32I.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/ai/agent/speedSampleCache.ts
+var SPEED_SAMPLE_DISK_CACHE_TTL_MS = 10 * 6e4;
+var SPEED_SAMPLE_SCAN_BUDGET_MS = 8e3;
+var SPEED_SAMPLE_CACHE_VERSION = 1;
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var sanitizeSample = (value) => {
+  if (!value || typeof value !== "object") return null;
+  const sample = value;
+  const clean = {};
+  if (isFiniteNumber(sample.firstOutputMs)) clean.firstOutputMs = sample.firstOutputMs;
+  if (isFiniteNumber(sample.callDurationMs)) clean.callDurationMs = sample.callDurationMs;
+  if (isFiniteNumber(sample.output_tokens)) clean.output_tokens = sample.output_tokens;
+  return clean.firstOutputMs === void 0 && clean.callDurationMs === void 0 ? null : clean;
+};
+async function readSpeedSamplesCache(cachePath, options) {
+  const ttlMs = isFiniteNumber(options.ttlMs) ? options.ttlMs : SPEED_SAMPLE_DISK_CACHE_TTL_MS;
+  try {
+    const fs = await import("node:fs/promises");
+    const raw = await fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (parsed.version !== SPEED_SAMPLE_CACHE_VERSION) return null;
+    if (parsed.userId !== options.userId) return null;
+    if (!isFiniteNumber(parsed.at)) return null;
+    const age = options.now - parsed.at;
+    if (age < 0 || age >= ttlMs) return null;
+    const samples = /* @__PURE__ */ new Map();
+    const source = parsed.samples;
+    if (!source || typeof source !== "object") return null;
+    for (const [model, list] of Object.entries(source)) {
+      if (!model || !Array.isArray(list)) continue;
+      const cleaned = [];
+      for (const entry of list) {
+        const sample = sanitizeSample(entry);
+        if (sample) cleaned.push(sample);
+      }
+      samples.set(model, cleaned);
+    }
+    return samples;
+  } catch {
+    return null;
+  }
+}
+async function writeSpeedSamplesCache(cachePath, payload) {
+  try {
+    const fs = await import("node:fs/promises");
+    const path2 = await import("node:path");
+    await fs.mkdir(path2.dirname(cachePath), { recursive: true });
+    await fs.writeFile(cachePath, JSON.stringify(payload), "utf8");
+  } catch {
+  }
+}
+
+// packages/ai/token/observedSpeedResolver.ts
+var DEFAULT_OBSERVED_SPEED_SAMPLE_SIZE = 20;
+var MIN_THROUGHPUT_WINDOW_MS = 200;
+var MAX_PLAUSIBLE_OUTPUT_TPS = 3e3;
+var isFiniteNumber2 = (value) => typeof value === "number" && Number.isFinite(value);
+var medianOf = (values) => {
+  if (values.length === 0) return void 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+function resolveObservedSpeed(records, options = {}) {
+  const limit = isFiniteNumber2(options.limit) ? Math.max(0, Math.floor(options.limit)) : DEFAULT_OBSERVED_SPEED_SAMPLE_SIZE;
+  const sample = Array.isArray(records) ? records.slice(0, limit) : [];
+  const firstOutputSamples = [];
+  const tpsSamples = [];
+  for (const record of sample) {
+    if (!record || typeof record !== "object") continue;
+    const { firstOutputMs, callDurationMs, output_tokens: outputTokens } = record;
+    const firstOutput = normalizeTimingMs(firstOutputMs);
+    const callDuration = normalizeTimingMs(callDurationMs);
+    if (firstOutput !== void 0) {
+      firstOutputSamples.push(firstOutput);
+    }
+    if (firstOutput !== void 0 && callDuration !== void 0 && callDuration - firstOutput >= MIN_THROUGHPUT_WINDOW_MS && isFiniteNumber2(outputTokens) && outputTokens > 0) {
+      const seconds = (callDuration - firstOutput) / 1e3;
+      const tokensPerSecond = outputTokens / seconds;
+      if (isFiniteNumber2(tokensPerSecond) && tokensPerSecond <= MAX_PLAUSIBLE_OUTPUT_TPS) {
+        tpsSamples.push(tokensPerSecond);
+      }
+    }
+  }
+  const medianFirstOutputMs = medianOf(firstOutputSamples);
+  const medianTps = medianOf(tpsSamples);
+  return {
+    firstOutputSampleCount: firstOutputSamples.length,
+    throughputSampleCount: tpsSamples.length,
+    ...medianFirstOutputMs !== void 0 ? { medianFirstOutputMs: Math.round(medianFirstOutputMs) } : {},
+    ...medianTps !== void 0 ? { medianOutputTokensPerSecond: Math.round(medianTps * 100) / 100 } : {}
+  };
+}
+
+// packages/ai/agent/candidateSpeedContext.ts
+var OBSERVED_SPEED_WINDOW = 50;
+var MIN_OBSERVED_FIRST_OUTPUT_SAMPLES = 5;
+var SPEED_SAMPLES_CACHE_TTL_MS = 5 * 6e4;
+var SPEED_SAMPLES_CACHE_MAX_ENTRIES = 500;
+var MAX_PLAUSIBLE_AA_FIRST_ANSWER_S = 60;
+function normalizeSpeedModelName(raw) {
+  const name = raw.trim().toLowerCase();
+  const slash = name.lastIndexOf("/");
+  return slash === -1 ? name : name.slice(slash + 1);
+}
+var isFiniteNumber3 = (value) => typeof value === "number" && Number.isFinite(value);
+var REASONING_EFFORT_SUFFIXES = ["minimal", "low", "medium", "high", "xhigh"];
+var REASONING_EFFORT_SUFFIX_RE = new RegExp(`-(?:${REASONING_EFFORT_SUFFIXES.join("|")})$`);
+function stripReasoningEffortSuffix(model) {
+  const base = model.replace(REASONING_EFFORT_SUFFIX_RE, "");
+  return base && base !== model ? base : null;
+}
+function resolveOneBare(model, samplesByModel) {
+  const observed = resolveObservedSpeed(samplesByModel.get(model) ?? [], {
+    limit: OBSERVED_SPEED_WINDOW
+  });
+  if (observed.firstOutputSampleCount >= MIN_OBSERVED_FIRST_OUTPUT_SAMPLES && observed.medianFirstOutputMs !== void 0) {
+    return {
+      source: "observed",
+      firstOutputMs: observed.medianFirstOutputMs,
+      ...observed.medianOutputTokensPerSecond !== void 0 ? { outputTps: observed.medianOutputTokensPerSecond } : {},
+      firstOutputSamples: observed.firstOutputSampleCount,
+      tpsSamples: observed.throughputSampleCount
+    };
+  }
+  const aa = getModelAbility(model)?.aaSnapshot;
+  if (!aa) return null;
+  const firstAnswerTokenS = isFiniteNumber3(aa.firstAnswerTokenS) && aa.firstAnswerTokenS <= MAX_PLAUSIBLE_AA_FIRST_ANSWER_S ? aa.firstAnswerTokenS : void 0;
+  if (!isFiniteNumber3(aa.outputSpeedTps) && firstAnswerTokenS === void 0) {
+    return null;
+  }
+  return {
+    source: "aa",
+    ...firstAnswerTokenS !== void 0 ? { firstAnswerTokenS } : {},
+    ...isFiniteNumber3(aa.outputSpeedTps) ? { outputTps: aa.outputSpeedTps } : {},
+    measuredAt: aa.measuredAt
+  };
+}
+function resolveOne(model, samplesByModel) {
+  const direct = resolveOneBare(model, samplesByModel);
+  if (direct) return { model, ...direct };
+  const base = stripReasoningEffortSuffix(model);
+  if (!base) return null;
+  const stripped = resolveOneBare(base, samplesByModel);
+  return stripped ? { model, ...stripped } : null;
+}
+function resolveCandidateSpeedFacts(models, samplesByModel) {
+  const unique = [
+    ...new Set(
+      models.filter((model) => typeof model === "string").map(normalizeSpeedModelName).filter(Boolean)
+    )
+  ];
+  return unique.map((model) => resolveOne(model, samplesByModel)).filter((fact) => fact !== null);
+}
+var formatSeconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+var formatTps = (tps) => String(Math.round(tps));
+var SPEED_CONTEXT_HEADER = "speed (observed=\u672C\u7528\u6237\u6700\u8FD1\u8C03\u7528\u4E2D\u4F4D\u6570, firstOutput \u542B\u63A8\u7406\u8F93\u51FA; aa=Artificial Analysis \u5FEB\u7167, firstAnswer \u542B\u601D\u8003\u65F6\u95F4, \u4E24\u6E90\u4E0D\u53EF\u76F4\u63A5\u6BD4\u8F83; tps=n/a \u8868\u793A\u65E0\u53EF\u4FE1\u541E\u5410\u6837\u672C):";
+function formatCandidateSpeedFacts(facts) {
+  if (facts.length === 0) return null;
+  const lines = facts.map((fact) => {
+    if (fact.source === "observed") {
+      const tps = fact.outputTps !== void 0 ? formatTps(fact.outputTps) : "n/a";
+      return `  ${fact.model}: firstOutput=${formatSeconds(fact.firstOutputMs ?? 0)} tps=${tps} [observed n=${fact.firstOutputSamples ?? 0} tpsN=${fact.tpsSamples ?? 0}]`;
+    }
+    const parts = [];
+    if (fact.firstAnswerTokenS !== void 0) parts.push(`firstAnswer=${fact.firstAnswerTokenS.toFixed(1)}s`);
+    parts.push(`tps=${fact.outputTps !== void 0 ? formatTps(fact.outputTps) : "n/a"}`);
+    return `  ${fact.model}: ${parts.join(" ")} [aa measuredAt=${fact.measuredAt}]`;
+  });
+  return `${SPEED_CONTEXT_HEADER}
+${lines.join("\n")}`;
+}
+function buildCandidateSpeedContext(models, samplesByModel) {
+  return formatCandidateSpeedFacts(resolveCandidateSpeedFacts(models, samplesByModel));
+}
+var SPEED_SAMPLE_PAGE_SIZE = 2e3;
+var eventTime = (value) => {
+  if (isFiniteNumber3(value.timestamp)) return value.timestamp;
+  if (isFiniteNumber3(value.createdAt)) return value.createdAt;
+  return 0;
+};
+function collectSample(collected, value) {
+  if (typeof value.model !== "string") return;
+  if (!isFiniteNumber3(value.firstOutputMs) && !isFiniteNumber3(value.callDurationMs)) return;
+  const model = normalizeSpeedModelName(value.model);
+  if (!model) return;
+  const list = collected.get(model) ?? [];
+  list.push({
+    t: eventTime(value),
+    firstOutputMs: value.firstOutputMs,
+    callDurationMs: value.callDurationMs,
+    output_tokens: value.output_tokens
+  });
+  collected.set(model, list);
+}
+function finalizeSamples(collected) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [model, list] of collected) {
+    list.sort((a, b) => b.t - a.t);
+    result.set(
+      model,
+      list.slice(0, OBSERVED_SPEED_WINDOW).map(({ t: _t, ...sample }) => sample)
+    );
+  }
+  return result;
+}
+async function collectRecentSpeedSamples(db, userId, options = {}) {
+  const pageSize = isFiniteNumber3(options.pageSize) && options.pageSize > 0 ? Math.floor(options.pageSize) : SPEED_SAMPLE_PAGE_SIZE;
+  const budgetMs = isFiniteNumber3(options.budgetMs) ? options.budgetMs : Number.POSITIVE_INFINITY;
+  const { start, end } = createTokenKey.rangeOfUser(userId);
+  const failedPrefix = createKey("token", userId, "failed-call", "");
+  const collected = /* @__PURE__ */ new Map();
+  const startedAt = Date.now();
+  let lastKey;
+  let budgetExhausted = false;
+  while (true) {
+    if (Date.now() - startedAt >= budgetMs) {
+      budgetExhausted = true;
+      break;
+    }
+    const pageOptions = {
+      ...lastKey === void 0 ? { gte: start } : { gt: lastKey },
+      lte: end,
+      limit: pageSize
+    };
+    let accepted = 0;
+    let newestKey = lastKey;
+    for await (const [key, raw] of db.iterator(pageOptions)) {
+      if (typeof key !== "string") continue;
+      if (lastKey !== void 0 && key <= lastKey) continue;
+      accepted += 1;
+      newestKey = key;
+      if (key.startsWith(failedPrefix)) continue;
+      if (!raw || typeof raw !== "object") continue;
+      collectSample(collected, raw);
+    }
+    if (accepted === 0 || accepted < pageSize) break;
+    lastKey = newestKey;
+  }
+  return { samples: finalizeSamples(collected), budgetExhausted };
+}
+async function loadRecentSpeedSamples(db, userId, options = {}) {
+  const { samples } = await collectRecentSpeedSamples(db, userId, options);
+  return samples;
+}
+async function loadSpeedSamplesWithDiskCache(db, userId, now, cache) {
+  try {
+    const ttlMs = isFiniteNumber3(cache.ttlMs) ? cache.ttlMs : SPEED_SAMPLE_DISK_CACHE_TTL_MS;
+    const cached = await readSpeedSamplesCache(cache.cachePath, { userId, now, ttlMs });
+    if (cached) return cached;
+    const { samples, budgetExhausted } = await collectRecentSpeedSamples(db, userId, {
+      pageSize: cache.pageSize,
+      budgetMs: isFiniteNumber3(cache.budgetMs) ? cache.budgetMs : SPEED_SAMPLE_SCAN_BUDGET_MS
+    });
+    if (budgetExhausted) return /* @__PURE__ */ new Map();
+    await writeSpeedSamplesCache(cache.cachePath, {
+      version: SPEED_SAMPLE_CACHE_VERSION,
+      userId,
+      at: now,
+      samples: Object.fromEntries(samples)
+    });
+    return samples;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+var samplesCache = /* @__PURE__ */ new Map();
+function writeSamplesCache(userId, now, samples) {
+  for (const [key, entry] of samplesCache) {
+    if (now - entry.at >= SPEED_SAMPLES_CACHE_TTL_MS) samplesCache.delete(key);
+  }
+  samplesCache.delete(userId);
+  samplesCache.set(userId, { at: now, samples });
+  while (samplesCache.size > SPEED_SAMPLES_CACHE_MAX_ENTRIES) {
+    const oldest = samplesCache.keys().next().value;
+    if (oldest === void 0) break;
+    samplesCache.delete(oldest);
+  }
+}
+async function loadCachedSpeedSamples(db, userId, now) {
+  const hit = samplesCache.get(userId);
+  if (hit && now - hit.at < SPEED_SAMPLES_CACHE_TTL_MS) return hit.samples;
+  const samples = await loadRecentSpeedSamples(db, userId);
+  writeSamplesCache(userId, now, samples);
+  return samples;
+}
+async function injectSpeedContextIntoListAgentsResult(result, options = {}) {
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(result);
+    } catch {
+      return result;
+    }
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.agents)) return result;
+    const models = parsed.agents.map((agent) => agent?.model).filter((model) => typeof model === "string");
+    if (models.length === 0) return result;
+    const now = options.now ?? Date.now();
+    let samples = /* @__PURE__ */ new Map();
+    const userId = typeof options.userId === "string" ? options.userId.trim() : "";
+    if (options.db && userId) {
+      try {
+        samples = options.diskCache ? await loadSpeedSamplesWithDiskCache(options.db, userId, now, options.diskCache) : await loadCachedSpeedSamples(options.db, userId, now);
+      } catch {
+        samples = /* @__PURE__ */ new Map();
+      }
+    }
+    const speedContext = buildCandidateSpeedContext(models, samples);
+    return speedContext ? JSON.stringify({ ...parsed, speedContext }) : result;
+  } catch {
+    return result;
+  }
+}
+
+// packages/cli/agentListCommands.ts
+import path from "node:path";
+var discardOutput = { write: () => void 0 };
+function resolveSpeedSamplesCachePath(env, userId) {
+  const safeUserId = userId.replace(/[^A-Za-z0-9._-]/g, "_");
+  const mergedEnv = { ...process.env, ...env };
+  return path.join(resolveNoloHome({ env: mergedEnv }), "cache", `speed-samples-${safeUserId}.json`);
+}
+async function runAgentListCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const { wantJson, wantSafe, publicOnly, scope: requestedScope, idsOnly, showUnavailable, verbose, query } = parseAgentListArgs(args);
+  if (requestedScope && !["preferred", "public", "all"].includes(requestedScope)) {
+    throw new Error(`Invalid scope '${requestedScope}'`);
+  }
+  if (requestedScope && publicOnly && requestedScope !== "public") {
+    throw new Error(`Conflicting arguments: scope='${requestedScope}' conflicts with publicOnly=true.`);
+  }
+  const scope = requestedScope ?? "preferred";
+  const spaceInput = readOption(args, "--space") ?? readOption(args, "--space-id");
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent list could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveServerCandidates(args, env, serverUrl);
+  try {
+    let agents;
+    let source;
+    let serverFailures = [];
+    try {
+      const remoteResult = await listRemoteAgentsAcrossServers({
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls,
+        userId
+      });
+      agents = remoteResult.agents;
+      serverFailures = remoteResult.failures;
+      source = "global-cache";
+    } catch {
+      try {
+        const db = deps.db ?? await getReadableCliDb(output);
+        agents = await listLocalCachedAgents({ db, userId });
+        source = "local-cache";
+      } catch {
+        agents = await listRemoteAgents({
+          authToken,
+          fallbackFetchImpl,
+          fetchImpl,
+          serverUrl,
+          userId,
+          queryUserRecords,
+          readDbRecord
+        });
+        source = "remote-cache";
+      }
+    }
+    if (scope !== "preferred") {
+      const publicAgents = await Promise.all(serverUrls.map((url) => listRemotePublicAgents({
+        authToken,
+        fetchImpl,
+        serverUrl: url,
+        limit: 500
+      })));
+      agents = publicAgents.flat();
+      if (scope === "all") {
+        const preferred = await listRemoteAgentsAcrossServers({
+          authToken,
+          fallbackFetchImpl,
+          fetchImpl,
+          serverUrls,
+          userId
+        });
+        agents = [...preferred.agents, ...agents];
+      }
+    }
+    agents = agents.filter((agent) => agent.privateKey.startsWith("agent-"));
+    let resolvedSpaceId = null;
+    let spaceContentKeys = null;
+    if (spaceInput) {
+      const { spaceId, spaceKey } = buildSpaceLookup(spaceInput);
+      resolvedSpaceId = spaceId;
+      const spaceRead = await readLiveDbRecordAfterTombstoneMerge({
+        authToken,
+        dbKey: spaceKey,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls
+      });
+      serverFailures = [...serverFailures, ...spaceRead.failures];
+      const spaceRecord = spaceRead.record;
+      const currentSpaceContentKeys = getSpaceContentKeys(spaceRecord);
+      spaceContentKeys = currentSpaceContentKeys;
+      agents = agents.filter(
+        (agent) => currentSpaceContentKeys.has(agent.privateKey) || currentSpaceContentKeys.has(agent.publicKey) || currentSpaceContentKeys.has(agent.id)
+      );
+    }
+    if (source === "global-cache") {
+      await decorateAgentsWithPublicStatusAcrossServers({
+        agents,
+        authToken,
+        fallbackFetchImpl,
+        fetchImpl,
+        serverUrls
+      });
+    }
+    if (publicOnly) {
+      agents = agents.filter((agent) => agent.publicRecordExists);
+    }
+    const originalAgentDeadlines = new Map(agents.map((agent) => [agent.privateKey, agent.nextAvailableAt]));
+    agents = applyCredentialAvailability(
+      agents,
+      await readCredentialAvailability(env).catch(() => ({}))
+    );
+    let unavailableCount = agents.filter((agent) => isAgentUnavailableNow(agent)).length;
+    let agentsForOutput = showUnavailable ? agents : agents.filter((agent) => !isAgentUnavailableNow(agent));
+    if (query && typeof query === "string" && query.trim()) {
+      agentsForOutput = agentsForOutput.filter((agent) => matchesAgentQuery(agent, query));
+    }
+    const refreshCandidates = !idsOnly ? [.../* @__PURE__ */ new Set([...agentsForOutput, ...agents.filter(
+      (agent) => !agentsForOutput.includes(agent) && isAgentUnavailableNow(agent) && agent.credentialConfigured === true && (!query || !String(query).trim() || matchesAgentQuery(agent, query))
+    )])] : agentsForOutput;
+    if (!idsOnly) {
+      const fresh = await refreshSubscriptionQuotas({
+        entries: refreshCandidates.map((agent) => ({
+          key: agent.privateKey,
+          ...agent.quota ? { quota: agent.quota } : {},
+          probeable: agent.credentialConfigured === true
+        })),
+        env,
+        cliArgs: args,
+        fetchImpl
+      });
+      const now = Date.now();
+      for (const agent of refreshCandidates) {
+        const quota = fresh[agent.privateKey];
+        if (!quota) continue;
+        agent.quota = quota;
+        try {
+          const key = resolveCredentialKeyWithFallback(agent);
+          if (!key) continue;
+          const entry = await readCredentialEntry(key, env);
+          if (entry && shouldClearCooldownFromQuota(entry, quota, now)) {
+            await clearCredentialAvailabilityIfMarkedAt(key, entry.markedAt, env);
+            const remainingAvailability = await readCredentialAvailability(env).catch(() => ({}));
+            for (const sibling of agents) {
+              if (resolveCredentialKeyWithFallback(sibling) !== key) continue;
+              const originalDeadline = originalAgentDeadlines.get(sibling.privateKey);
+              if (typeof originalDeadline === "number") sibling.nextAvailableAt = originalDeadline;
+              else delete sibling.nextAvailableAt;
+              Object.assign(sibling, applyCredentialAvailability([sibling], remainingAvailability)[0]);
+            }
+          }
+        } catch {
+        }
+      }
+      unavailableCount = agents.filter((agent) => isAgentUnavailableNow(agent)).length;
+      if (!showUnavailable) {
+        agentsForOutput = agents.filter((agent) => !isAgentUnavailableNow(agent));
+        if (query && typeof query === "string" && query.trim()) {
+          agentsForOutput = agentsForOutput.filter((agent) => matchesAgentQuery(agent, query));
+        }
+      }
+    }
+    if (idsOnly) {
+      output.write(`${agentsForOutput.map((agent) => agent.id).join("\n")}
+`);
+      return 0;
+    }
+    if (wantSafe) {
+      const favoritesMap = await listFavoriteAgentIdsAcrossServers({
+        authToken,
+        fetchImpl,
+        serverUrls
+      }).catch(() => ({}));
+      const existingKeys = /* @__PURE__ */ new Set();
+      for (const agent of agents) {
+        existingKeys.add(agent.privateKey);
+        existingKeys.add(agent.publicKey);
+        existingKeys.add(agent.id);
+      }
+      const extraFavoriteRecords = [];
+      const hydratedFavoriteAgents = [];
+      for (const favKey of Object.keys(favoritesMap)) {
+        if (existingKeys.has(favKey)) continue;
+        try {
+          const favRead = await readLiveDbRecordAfterTombstoneMerge({
+            authToken,
+            dbKey: favKey,
+            fallbackFetchImpl,
+            fetchImpl,
+            serverUrls
+          });
+          const record = favRead.record;
+          if (!record || record.type && record.type !== "agent") continue;
+          const norm = normalizeListedAgent(record);
+          const candidateKeys = [record.dbKey, record.publicKey, record.id].filter((key) => typeof key === "string" && key.length > 0);
+          if (spaceContentKeys && !candidateKeys.some((key) => spaceContentKeys?.has(key))) {
+            continue;
+          }
+          if (norm) {
+            if (!favKey.startsWith("agent-pub-")) {
+              norm.verifiedAgentKey = favKey;
+              if (typeof record.userId === "string" && record.userId) {
+                norm.ownerId = record.userId;
+              }
+            }
+            agents.push(norm);
+            hydratedFavoriteAgents.push(norm);
+            existingKeys.add(norm.privateKey);
+            existingKeys.add(norm.publicKey);
+            existingKeys.add(norm.id);
+          } else {
+            extraFavoriteRecords.push(record);
+            for (const key of candidateKeys) existingKeys.add(key);
+          }
+        } catch {
+        }
+      }
+      if (source === "global-cache" && hydratedFavoriteAgents.length > 0) {
+        await decorateAgentsWithPublicStatusAcrossServers({
+          agents: hydratedFavoriteAgents,
+          authToken,
+          fallbackFetchImpl,
+          fetchImpl,
+          serverUrls
+        });
+      }
+      const safeRecords = [...agents, ...extraFavoriteRecords].map((record) => toDiscoverySafeAgentSummary(record, { favoritesMap, userId })).filter((agent) => publicOnly ? agent.isPublic === true : true);
+      const discovery = buildAgentDiscoveryResult({
+        agents: safeRecords,
+        scope: "all",
+        query,
+        showUnavailable,
+        verbose
+      });
+      const listResult = JSON.stringify({
+        success: true,
+        userId,
+        ...resolvedSpaceId ? { spaceId: resolvedSpaceId } : {},
+        total: discovery.total,
+        unavailableCount: discovery.unavailableCount,
+        unavailableAgents: discovery.unavailableAgents,
+        credentialGroups: discovery.credentialGroups,
+        agents: discovery.agents
+      }, null, 2);
+      const withSpeedContext = await injectSpeedContextIntoListAgentsResult(listResult, {
+        db: deps.db ?? await getReadableCliDb(discardOutput),
+        userId,
+        diskCache: { cachePath: resolveSpeedSamplesCachePath(env, userId) }
+      });
+      output.write(withSpeedContext);
+      output.write("\n");
+      return 0;
+    }
+    if (wantJson) {
+      const credentialGroups = summarizeCredentialGroups(agentsForOutput);
+      output.write(JSON.stringify({
+        userId,
+        ...resolvedSpaceId ? { spaceId: resolvedSpaceId } : {},
+        targetServers: serverUrls,
+        ...serverFailures.length ? { serverFailures } : {},
+        total: agentsForOutput.length,
+        publicCount: agentsForOutput.filter((agent) => agent.publicRecordExists).length,
+        unavailableCount,
+        credentialGroups,
+        source,
+        agents: agentsForOutput
+      }, null, 2));
+      output.write("\n");
+      return 0;
+    }
+    output.write(`userId: ${userId}
+`);
+    if (resolvedSpaceId) {
+      output.write(`spaceId: ${resolvedSpaceId}
+`);
+    }
+    output.write(`targetServers: ${serverUrls.join(", ")}
+`);
+    if (serverFailures.length) {
+      output.write(`serverFailures: ${serverFailures.length}
+`);
+    }
+    output.write(`total agents: ${agentsForOutput.length}
+`);
+    output.write(`public agents: ${agentsForOutput.filter((agent) => agent.publicRecordExists).length}
+`);
+    if (unavailableCount > 0 && !showUnavailable) {
+      output.write(t("agent.unavailableHidden", String(unavailableCount)));
+      const unavailableList = agents.filter((agent) => isAgentUnavailableNow(agent));
+      for (const unavail of unavailableList) {
+        const remainingSec = Math.max(0, Math.ceil(((unavail.nextAvailableAt ?? 0) - Date.now()) / 1e3));
+        const quotaSummary = formatQuotaSummary(unavail.quota);
+        const quotaText = quotaSummary ? ` (${quotaSummary})` : "";
+        output.write(
+          t("agent.rateLimitedRecovery", unavail.name, unavail.id, String(remainingSec), quotaText)
+        );
+      }
+    }
+    output.write(`source: ${source}
+`);
+    if (agentsForOutput.length === 0) {
+      output.write("\n(no agents found)\n");
+      return 0;
+    }
+    for (const agent of agentsForOutput) {
+      const status = agent.publicRecordExists ? "public" : "private";
+      const flagMismatch = agent.isPublicFlag !== agent.publicRecordExists ? ` flag=${agent.isPublicFlag}` : "";
+      const credentialLine = agent.credentialConfigured ? `credentialConfigured=true${agent.credentialRef ? ` credentialRef=${agent.credentialRef}` : ""}${agent.apiKeyRef ? ` apiKeyRef=${agent.apiKeyRef}` : ""}` : "credentialConfigured=false";
+      const availabilityLine = typeof agent.nextAvailableAt === "number" && agent.nextAvailableAt > Date.now() ? `nextAvailableAt=${new Date(agent.nextAvailableAt).toISOString()}` : "nextAvailableAt=now";
+      const quotaSummary = formatQuotaSummary(agent.quota);
+      const quotaLine = `quota=${quotaSummary ?? "-"}`;
+      output.write(
+        [
+          `
+[${status}] ${agent.name}`,
+          `id=${agent.id}`,
+          `type=${agent.type ?? "-"}`,
+          `model=${agent.model}`,
+          `updatedAt=${agent.updatedAt ?? "-"}`,
+          // 不输出 privateKey（dbKey 属敏感标识，与 web 端 listAgentsFunc 降权
+          // 对齐；需要完整记录请用 --json）。
+          // 私有 agent（publicRecordExists=false）的公开记录不存在，输出 "-" 而非
+          // 一个库里不存在的 agent-pub-<id>，避免误导调用方拿它去 readAgent。
+          `publicKey=${agent.publicRecordExists ? agent.publicKey : "-"}${flagMismatch}`,
+          `tools=${agent.tools.join(", ") || "-"}`,
+          credentialLine,
+          availabilityLine,
+          quotaLine
+        ].join("\n")
+      );
+      output.write("\n");
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent list failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+export {
+  resolveSpeedSamplesCachePath,
+  runAgentListCommand
+};