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

package/_executeModel-XIGO7HW5.js

@@ -0,0 +1,198 @@
+import {
+  filterAndCleanMessages,
+  sendOpenAICompletionsRequest
+} from "./chunk-SL3EPWB4.js";
+import "./chunk-2LMT6K6N.js";
+import "./chunk-VIDPVFP3.js";
+import {
+  fetchAgentContexts
+} from "./chunk-YIJFUVKA.js";
+import {
+  generateRequestBody,
+  mergeReferences,
+  performFetchRequest
+} from "./chunk-2JHWPW5B.js";
+import "./chunk-DA2OEKS6.js";
+import "./chunk-2MALU52L.js";
+import "./chunk-UVPF33PW.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-XKIMRZO2.js";
+import "./chunk-3LY4F7SV.js";
+import "./chunk-VP4WJWKW.js";
+import "./chunk-63W5N6P3.js";
+import "./chunk-IECI4YHR.js";
+import "./chunk-AR7ZSGDI.js";
+import "./chunk-NXZGF7F7.js";
+import "./chunk-HEIIIZBX.js";
+import {
+  selectAllMsgs,
+  selectCurrentDialogConfig,
+  updateTokensAction
+} from "./chunk-KTI2WDDG.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-OVGXXUVI.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-543C7RDK.js";
+import "./chunk-IYQV26RA.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-AUGHVUFE.js";
+import "./chunk-H2RMRZJE.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-USZMK5UT.js";
+import "./chunk-NE3E3XJ2.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import {
+  getApiEndpoint
+} from "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-5MIDPSSK.js";
+import {
+  extractCustomId
+} from "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-IAXBCTTE.js";
+import {
+  selectCurrentServer
+} from "./chunk-VEJLAVTC.js";
+import "./chunk-Y5GCAMGP.js";
+import {
+  read
+} from "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import {
+  selectIdentityToken
+} from "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/integrations/openai/chatCompletionStreamMode.ts
+var applyChatCompletionsStreamMode = (body, stream) => {
+  const nextBody = { ...body, stream };
+  if (!stream) {
+    delete nextBody.stream_options;
+  }
+  return nextBody;
+};
+
+// packages/ai/agent/_executeModel.ts
+var _executeModel = async (options, args, thunkApi) => {
+  const { isStreaming, withAgentContext, withChatHistory, agentConfigOverrides } = options;
+  const { getState, dispatch, rejectWithValue } = thunkApi;
+  const { content } = args;
+  const state = getState();
+  let agentConfig;
+  if (args.llmConfig) {
+    agentConfig = args.llmConfig;
+  } else if (args.agentConfig) {
+    agentConfig = args.agentConfig;
+  } else {
+    const agentKey = args.agentKey || selectCurrentDialogConfig(state)?.cybots?.[0];
+    if (!agentKey) {
+      const msg = "Model execution failed: No llmConfig, agentConfig, or agentKey provided.";
+      console.error(msg);
+      return rejectWithValue(msg);
+    }
+    try {
+      agentConfig = await dispatch(read({ dbKey: agentKey })).unwrap();
+    } catch (error) {
+      console.error(`_executeModel failed to load agent [${agentKey}]`, error);
+      return rejectWithValue(error.message);
+    }
+  }
+  try {
+    const resolvedConfig = agentConfigOverrides ? { ...agentConfig, ...agentConfigOverrides } : agentConfig;
+    const resolvedAgentConfig = resolvedConfig;
+    const agentContexts = withAgentContext ? await fetchAgentContexts(mergeReferences(resolvedAgentConfig.references, selectCurrentDialogConfig(state)?.extraReferences), dispatch) : {};
+    let messages;
+    if (withChatHistory) {
+      messages = filterAndCleanMessages(selectAllMsgs(state));
+      messages.push({ role: "user", content: args.content });
+    } else {
+      messages = [{ role: "user", content: args.content }];
+    }
+    const requestBody = generateRequestBody({
+      agentConfig: resolvedAgentConfig,
+      messages,
+      userInput: content,
+      contexts: agentContexts
+    });
+    const bodyData = applyChatCompletionsStreamMode(requestBody, isStreaming);
+    const currentDialogKey = selectCurrentDialogConfig(state)?.dbKey ?? "";
+    if (isStreaming) {
+      await sendOpenAICompletionsRequest({
+        bodyData,
+        agentConfig: resolvedAgentConfig,
+        thunkApi,
+        dialogKey: currentDialogKey,
+        parentMessageId: args.parentMessageId
+      });
+    } else {
+      const response = await performFetchRequest({
+        agentConfig: resolvedAgentConfig,
+        api: getApiEndpoint(resolvedAgentConfig),
+        bodyData,
+        currentServer: selectCurrentServer(state),
+        token: selectIdentityToken(state) ?? "",
+        dialogId: extractCustomId(args.billingDialogKey ?? currentDialogKey) || void 0
+      });
+      if (!response.ok) {
+        let message = `Model request failed with HTTP ${response.status}`;
+        try {
+          const errorBody = await response.json();
+          const upstreamMessage = typeof errorBody?.error?.message === "string" ? errorBody.error.message : typeof errorBody?.message === "string" ? errorBody.message : "";
+          if (upstreamMessage.trim()) message = upstreamMessage.trim();
+        } catch {
+        }
+        throw new Error(message);
+      }
+      const result = await response.json();
+      const content2 = result?.choices?.[0]?.message?.content;
+      if (typeof content2 !== "string") {
+        const upstreamMessage = typeof result?.error?.message === "string" ? result.error.message : "";
+        throw new Error(
+          upstreamMessage.trim() || "Model response missing choices[0].message.content"
+        );
+      }
+      if (args.billingDialogKey && result?.usage) {
+        await updateTokensAction(
+          {
+            dialogId: extractCustomId(args.billingDialogKey),
+            dialogKey: args.billingDialogKey,
+            usage: result.usage,
+            agentConfig: resolvedAgentConfig
+          },
+          thunkApi
+        );
+      }
+      return content2;
+    }
+  } catch (error) {
+    console.error(`_executeModel failed`, error);
+    return rejectWithValue(error.message);
+  }
+};
+export {
+  _executeModel
+};

package/action-PAXRPJJF.js

@@ -0,0 +1,27 @@
+import {
+  shareResourceAction
+} from "./chunk-IAXBCTTE.js";
+import "./chunk-VEJLAVTC.js";
+import "./chunk-Y5GCAMGP.js";
+import "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  shareResourceAction
+};

package/addContentAction-CZVWF3QZ.js

@@ -0,0 +1,25 @@
+import {
+  addContentAction
+} from "./chunk-H2RMRZJE.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  addContentAction
+};

package/addDialogAgentAction-CCIDTPHC.js

@@ -0,0 +1,67 @@
+import {
+  addDialogAgentIds
+} from "./chunk-Z4NR32XR.js";
+import {
+  require_date_fns
+} from "./chunk-M76ECQRD.js";
+import {
+  getActiveDialogKey
+} from "./chunk-3ASDTTEI.js";
+import {
+  patch,
+  selectById
+} from "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/chat/dialog/actions/addDialogAgentAction.ts
+var import_date_fns = __toESM(require_date_fns());
+var addDialogAgentAction = async (agentIds, thunkApi) => {
+  const { dispatch, getState } = thunkApi;
+  const state = getState();
+  const currentDialogKey = getActiveDialogKey();
+  if (!currentDialogKey) {
+    throw new Error("No current dialog selected");
+  }
+  const dialogConfig = selectById(state, currentDialogKey);
+  if (!dialogConfig) {
+    throw new Error("Dialog configuration not found");
+  }
+  const idsToAdd = Array.isArray(agentIds) ? agentIds : [agentIds];
+  if (idsToAdd.length === 0) {
+    throw new Error("No agent IDs provided");
+  }
+  const validIds = idsToAdd.filter((id) => id && typeof id === "string");
+  if (validIds.length === 0) {
+    throw new Error("No valid agent IDs provided");
+  }
+  const updatedAgents = addDialogAgentIds(dialogConfig.cybots || [], validIds);
+  const changes = {
+    cybots: updatedAgents,
+    updatedAt: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date())
+  };
+  const updatedConfig = await dispatch(
+    patch({ dbKey: currentDialogKey, changes })
+  ).unwrap();
+  return updatedConfig;
+};
+export {
+  addDialogAgentAction
+};

package/agentDeleteCommand-47B24JYG.js

@@ -0,0 +1,323 @@
+import {
+  deleteDbRecordOnServers
+} from "./chunk-GEKCOPTN.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  resolveAgentRecordFromHybridStore
+} from "./chunk-6PWWWMI7.js";
+import "./chunk-364VYAX2.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveDeleteServerCandidates,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-5XH3NZ4T.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-NE3E3XJ2.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-DWLEOOGR.js";
+import {
+  Level
+} from "./chunk-6WD3OOJS.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/localLevelDbCleanup.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+async function clearAgentKeysFromLocalLevelDbs(args) {
+  const home = os.homedir();
+  const noloHome = process.env.NOLO_HOME?.trim() || path.join(home, ".nolo");
+  const dbPaths = [];
+  const cliDb = path.join(noloHome, "data", "leveldb");
+  if (fs.existsSync(cliDb)) dbPaths.push(cliDb);
+  const serverDbPath = process.env.NOLO_SERVER_DB_PATH?.trim();
+  if (serverDbPath && fs.existsSync(serverDbPath) && !dbPaths.includes(serverDbPath)) {
+    dbPaths.push(serverDbPath);
+  }
+  const cleaned = [];
+  for (const dbPath of dbPaths) {
+    try {
+      const db = new Level(dbPath, { valueEncoding: "json" });
+      await db.open();
+      try {
+        for (const key of args.keys) {
+          try {
+            await db.del(key);
+          } catch {
+          }
+        }
+        cleaned.push(dbPath);
+      } finally {
+        await db.close();
+      }
+    } catch {
+    }
+  }
+  return cleaned;
+}
+
+// packages/cli/agentDeleteCommand.ts
+var AGENT_PRIVATE_KEY_RE = /^agent-([^-]+)-(.+)$/i;
+var AGENT_PUBLIC_KEY_RE = /^agent-pub-(.+)$/i;
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function readOption(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : void 0;
+}
+function readAllPositional(args) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (!a || a.startsWith("-")) continue;
+    out.push(a);
+  }
+  return out;
+}
+function extractAgentId(agentKey) {
+  const pub = agentKey.match(AGENT_PUBLIC_KEY_RE);
+  if (pub) return pub[1];
+  const priv = agentKey.match(AGENT_PRIVATE_KEY_RE);
+  if (priv) return priv[2];
+  return void 0;
+}
+function extractUserId(agentKey) {
+  const priv = agentKey.match(AGENT_PRIVATE_KEY_RE);
+  if (priv) return priv[1];
+  return void 0;
+}
+function buildAgentKeys(agentKey, fallbackUserId) {
+  const agentId = extractAgentId(agentKey);
+  if (!agentId) return null;
+  const privateUserId = extractUserId(agentKey) ?? fallbackUserId;
+  if (!privateUserId) return null;
+  return {
+    agentId,
+    privateKey: `agent-${privateUserId}-${agentId}`,
+    publicKey: `agent-pub-${agentId}`
+  };
+}
+function printUsage(output) {
+  output.write("Usage: nolo agent delete <agentId|agentKey|agentUrl> [--yes] [--json]\n");
+  output.write(
+    "       nolo agent delete --id <agentId|agentKey|agentUrl> [--yes] [--json]\n"
+  );
+  output.write("\n");
+  output.write("\u5220\u9664\u4E00\u4E2A agent \u7684\u79C1\u6709\u8BB0\u5F55 (agent-{userId}-{id}) \u4E0E\u516C\u5F00\u8BB0\u5F55 (agent-pub-{id})\u3002\n");
+  output.write("\u670D\u52A1\u5668\u7AEF\u4E3A tombstone \u8F6F\u5220\u9664\uFF0CDELETE \u540E\u518D\u6B21 read \u4F1A\u8FD4\u56DE 404\u3002\n");
+  output.write("\n");
+  output.write("Flags:\n");
+  output.write("  --yes            \u771F\u6B63\u6267\u884C\u5220\u9664\uFF1B\u7F3A\u7701\u65F6\u4EC5 dry-run \u8F93\u51FA\u76EE\u6807\u6458\u8981\u3002\n");
+  output.write("  --json           \u8F93\u51FA JSON \u7ED3\u679C\u3002\n");
+  output.write("  --id <agent>     \u4E0E\u4F4D\u7F6E\u53C2\u6570\u7B49\u4EF7\uFF0C\u4F20\u5165 alias / dbKey / URL / 26-char id\u3002\n");
+  output.write("  --server / --server-url  \u4EC5\u5220\u9664\u6307\u5B9A\u670D\u52A1\u5668\uFF08\u4ECD\u4FDD\u7559\u96C6\u7FA4 fan-out \u4E4B\u5916\u7684\u526F\u672C\uFF09\u3002\n");
+  output.write("  --user <userId>  \u663E\u5F0F\u8986\u76D6 userId\uFF08\u4E0E AUTH_TOKEN \u4E0D\u4E00\u81F4\u5219\u62A5\u9519\uFF09\u3002\n");
+  output.write("  --token / --machine-key  \u4E34\u65F6\u8986\u76D6 AUTH_TOKEN\u3002\n");
+  output.write("\n");
+  output.write("Examples:\n");
+  output.write("  nolo agent delete 01MIMOREALPLUS0608 --yes\n");
+  output.write("  nolo agent delete https://nolo.chat/agent-0e95801d90-01MIMOREALPLUS0608 --yes --json\n");
+}
+async function runAgentDeleteCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printUsage(output);
+    return 0;
+  }
+  const explicitId = readOption(args, "--id");
+  const positionals = readAllPositional(args);
+  const agentInput = explicitId?.trim() || positionals[0]?.trim();
+  if (!agentInput) {
+    printUsage(output);
+    return 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write(
+      "[nolo] agent delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const tokenUserId = parseUserIdFromAuthToken(authToken);
+  if (!tokenUserId) {
+    output.write(
+      "[nolo] agent delete could not read userId from AUTH_TOKEN.\n"
+    );
+    return 1;
+  }
+  const userOverride = readOption(args, "--user");
+  if (userOverride && userOverride !== tokenUserId) {
+    output.write(
+      `[nolo] agent delete --user (${userOverride}) does not match AUTH_TOKEN userId (${tokenUserId}).
+`
+    );
+    return 1;
+  }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const json = hasFlag(args, "--json");
+  const shouldDelete = hasFlag(args, "--yes");
+  const serverUrl = resolveServerUrl(args, env);
+  const serverUrls = resolveDeleteServerCandidates(args, env, serverUrl);
+  let resolved;
+  try {
+    resolved = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+  } catch (error) {
+    const msg = toErrorMessage(error);
+    output.write(`[nolo] agent delete failed to resolve "${agentInput}": ${msg}
+`);
+    return 1;
+  }
+  if (!resolved) {
+    output.write(`[nolo] agent delete: agent not found: ${agentInput}
+`);
+    return 1;
+  }
+  const keys = buildAgentKeys(resolved.agentKey, tokenUserId);
+  if (!keys) {
+    output.write(
+      `[nolo] agent delete: cannot derive agent id from resolved key ${resolved.agentKey}.
+`
+    );
+    return 1;
+  }
+  const record = resolved.record;
+  const agentName = typeof record?.name === "string" && record.name.trim() ? record.name : "(unnamed)";
+  const resolvedBase = typeof record?.serverOrigin === "string" && record.serverOrigin ? record.serverOrigin : "";
+  let privateDeleteResults = [];
+  let publicDeleteResults = [];
+  if (shouldDelete) {
+    try {
+      privateDeleteResults = await deleteDbRecordOnServers({
+        authToken,
+        dbKey: keys.privateKey,
+        fetchImpl,
+        fallbackFetchImpl,
+        serverUrls
+      });
+      publicDeleteResults = await deleteDbRecordOnServers({
+        authToken,
+        dbKey: keys.publicKey,
+        fetchImpl,
+        fallbackFetchImpl,
+        serverUrls
+      });
+    } catch (error) {
+      const msg = toErrorMessage(error);
+      output.write(`[nolo] agent delete fan-out failed: ${msg}
+`);
+      return 1;
+    }
+  }
+  if (shouldDelete) {
+    try {
+      const cleanedPaths = await clearAgentKeysFromLocalLevelDbs({
+        keys: [keys.privateKey, keys.publicKey]
+      });
+      if (cleanedPaths.length > 0 && !json) {
+        output.write(`Cleaned local LevelDB copies: ${cleanedPaths.length}
+`);
+      }
+    } catch (error) {
+      const msg = toErrorMessage(error);
+      if (!json) output.write(`[nolo] local LevelDB cleanup skipped: ${msg}
+`);
+    }
+  }
+  const allResults = [...privateDeleteResults, ...publicDeleteResults];
+  const failed = allResults.filter((r) => !r.ok);
+  const succeededCount = allResults.length - failed.length;
+  const payload = {
+    agentKey: resolved.agentKey,
+    agentName,
+    agentId: keys.agentId,
+    privateKey: keys.privateKey,
+    publicKey: keys.publicKey,
+    resolvedBase: resolvedBase || null,
+    targetServers: serverUrls,
+    dryRun: !shouldDelete,
+    deleted: shouldDelete,
+    deleteResults: shouldDelete ? {
+      private: privateDeleteResults,
+      public: publicDeleteResults
+    } : void 0
+  };
+  if (json) {
+    output.write(JSON.stringify(payload, null, 2));
+    output.write("\n");
+  } else {
+    output.write(`agent: ${agentName}
+`);
+    output.write(`agentKey: ${resolved.agentKey}
+`);
+    output.write(`privateKey: ${keys.privateKey}
+`);
+    output.write(`publicKey: ${keys.publicKey}
+`);
+    output.write(`targetServers: ${serverUrls.join(", ")}
+`);
+    if (resolvedBase) output.write(`resolvedBase: ${resolvedBase}
+`);
+    if (!shouldDelete) {
+      output.write(
+        "\nDry-run only. Re-run with --yes to tombstone this agent on the target servers.\n"
+      );
+    } else {
+      if (privateDeleteResults.length || publicDeleteResults.length) {
+        output.write(
+          `Deleted on ${succeededCount}/${allResults.length} targets. ${failed.length ? `Failures: ${failed.map((r) => `${r.dbKey ?? ""}@${r.serverUrl} (${r.error ?? "unknown"})`).join("; ")}` : ""}
+`
+        );
+      } else {
+        output.write("No delete requests issued.\n");
+      }
+    }
+  }
+  return failed.length > 0 ? 1 : 0;
+}
+export {
+  runAgentDeleteCommand
+};