nolo-cli 0.1.41 → 0.1.43

package/cli/client/localRuntimeAdapter.ts

@@ -43,9 +43,13 @@ import {
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
 import { inferCaptureIntent } from "../../ai/policy/runtimePolicy";
+import { TOOL_PACKS } from "../../ai/tools/toolPacks";
 import { prepareTools } from "../../ai/tools/prepareTools";
-import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
 import {
+  LOCAL_CODEX_AGENT_ID,
+  LOCAL_CODEX_AGENT_KEY,
+  LOCAL_QODER_AGENT_ID,
+  LOCAL_QODER_AGENT_KEY,
   MIMO_MONTH_AGENT_KEY,
   NOLO_DEFAULT_AGENT_ID,
   NOLO_DEFAULT_AGENT_KEY,
@@ -62,7 +66,10 @@ import {
   readXhsProfileFunc,
   readXhsProfileFunctionSchema,
 } from "../../ai/tools/readXhsProfileTool";
-import { resolveDefaultXhsProfileDir } from "../../integrations/xhs-reader/bridge/readXhsProfileWithBridge";
+import {
+  readXPostFunc,
+  readXPostFunctionSchema,
+} from "../../ai/tools/readXPostTool";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
@@ -106,6 +113,7 @@ export type CliLocalRuntimeAdapterDeps = {
   cwd?: string;
   output?: { write(chunk: string): unknown };
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  readXPost?: typeof readXPostFunc;
   readXhsProfile?: typeof readXhsProfileFunc;
   executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
@@ -124,6 +132,55 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
+function resolveBuiltinLocalCliAgentConfig(agentRef: string, userId: string): AgentRuntimeAgentConfig | null {
+  const normalized = agentRef.trim();
+  if (normalized === LOCAL_CODEX_AGENT_KEY || normalized === LOCAL_CODEX_AGENT_ID) {
+    return {
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "Local Codex",
+      prompt: "You are a local Codex CLI coding agent. Use the workspace and dialog evidence available to you, keep changes scoped, run relevant checks, and report worktree, branch, commit or dirty diff, tests, and blockers.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+      toolNames: ["readFile", "searchFiles", "execShell"],
+      rawRecord: {
+        dbKey: LOCAL_CODEX_AGENT_KEY,
+        id: LOCAL_CODEX_AGENT_ID,
+        userId,
+        type: "agent",
+        name: "Local Codex",
+        apiSource: "cli",
+        provider: "cli",
+        cliProvider: "codex",
+      },
+    };
+  }
+  if (normalized === LOCAL_QODER_AGENT_KEY || normalized === LOCAL_QODER_AGENT_ID) {
+    return {
+      key: LOCAL_QODER_AGENT_KEY,
+      name: "Local Qoder",
+      prompt: "You are a local Qoder CLI coding agent. Use the workspace and dialog evidence available to you, keep changes scoped, run relevant checks, and report worktree, branch, commit or dirty diff, tests, and blockers.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "qoder",
+      model: "Qwen3.7-Max",
+      toolNames: ["readFile", "searchFiles", "execShell"],
+      rawRecord: {
+        dbKey: LOCAL_QODER_AGENT_KEY,
+        id: LOCAL_QODER_AGENT_ID,
+        userId,
+        type: "agent",
+        name: "Local Qoder",
+        apiSource: "cli",
+        provider: "cli",
+        cliProvider: "qoder",
+        model: "Qwen3.7-Max",
+      },
+    };
+  }
+  return null;
+}
+
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -371,6 +428,25 @@ function shouldExposeLocalPlatformTools(agentKey?: string) {
   return agentKey !== MIMO_MONTH_AGENT_KEY;
 }
 
+function addDefaultLightWebToolsForConfiguredAgents(
+  toolNames: string[],
+  agentConfig?: AgentRuntimeAgentConfig | null,
+) {
+  const explicitToolNames = Array.isArray((agentConfig as any)?.toolSurface?.explicitToolNames)
+    ? (agentConfig as any).toolSurface.explicitToolNames
+    : agentConfig?.toolNames;
+  if (!Array.isArray(explicitToolNames) || explicitToolNames.length === 0) return toolNames;
+  const webCapable = explicitToolNames.some((toolName) =>
+    toolName === "fetchWebpage" ||
+    toolName === "exa_search" ||
+    toolName === "read_x_post" ||
+    toolName === "read_xhs_profile" ||
+    toolName.startsWith("browser_")
+  );
+  if (!webCapable) return toolNames;
+  return [...new Set([...toolNames, ...TOOL_PACKS.LIGHT_WEB])];
+}
+
 function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
@@ -378,6 +454,14 @@ function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env:
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
+      listFilesDescriptionVariant: resolveListFilesDescriptionVariant(args.env),
+      listFilesParameterVariant: resolveListFilesParameterVariant(args.env),
+      readFileDescriptionVariant: resolveReadFileDescriptionVariant(args.env),
+      readFileParameterVariant: resolveReadFileParameterVariant(args.env),
+      globFilesDescriptionVariant: resolveGlobFilesDescriptionVariant(args.env),
+      globFilesParameterVariant: resolveGlobFilesParameterVariant(args.env),
+      searchFilesDescriptionVariant: resolveSearchFilesDescriptionVariant(args.env),
+      searchFilesParameterVariant: resolveSearchFilesParameterVariant(args.env),
     }),
     ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
     ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
@@ -385,44 +469,91 @@ function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env:
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
-  void args.env;
   const toolset = buildLocalWorkspaceToolset({
     declaredToolNames: args.toolNames,
     exposeShellTools: true,
+    useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args.env),
   });
   return toolset;
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
-  void args.env;
   return [
     ...buildLocalWorkspacePolicyToolNames({
       declaredToolNames: args.toolNames,
       exposeShellTools: true,
+      useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args.env),
     }),
-    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.toolNames ?? []).includes("read_x_post") ? ["read_x_post"] : []),
     ...((args.toolNames ?? []).includes("read_xhs_profile") ? ["read_xhs_profile"] : []),
     ...(args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
     ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
+function shouldUseDeclaredOnlyLocalWorkspaceTools(env: EnvLike) {
+  const value = env.NOLO_LOCAL_WORKSPACE_TOOLSET || env.NOLO_LOCAL_TOOLSET_MODE || "";
+  return value === "declared-only" || value === "declared";
+}
+
+function resolveGlobFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_GLOBFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveListFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_LISTFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveListFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_LISTFILES_PARAMETER_VARIANT);
+}
+
+function resolveReadFileDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_READFILE_DESCRIPTION_VARIANT);
+}
+
+function resolveReadFileParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_READFILE_PARAMETER_VARIANT);
+}
+
+function resolveGlobFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_GLOBFILES_PARAMETER_VARIANT);
+}
+
+function resolveSearchFilesDescriptionVariant(env: EnvLike) {
+  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_SEARCHFILES_DESCRIPTION_VARIANT);
+}
+
+function resolveSearchFilesParameterVariant(env: EnvLike) {
+  return resolveLocalWorkspaceParameterVariant(env.NOLO_SEARCHFILES_PARAMETER_VARIANT);
+}
+
+function resolveLocalWorkspaceDescriptionVariant(value: string | undefined) {
+  return value === "brief" || value === "strategy" || value === "workflow" || value === "antiShell"
+    ? value
+    : "strategy";
+}
+
+function resolveLocalWorkspaceParameterVariant(value: string | undefined) {
+  return value === "minimal" || value === "scoped" || value === "rich" ? value : "rich";
+}
+
 function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   const toolNames = new Set(args.toolNames ?? []);
   const tableTools = prepareTools(
     (args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
   );
   return [
-    ...(toolNames.has("taskRun")
+    ...(toolNames.has("read_xhs_profile")
       ? [{
           type: "function",
-          function: taskRunFunctionSchema,
+          function: readXhsProfileFunctionSchema,
         }]
       : []),
-    ...(toolNames.has("read_xhs_profile")
+    ...(toolNames.has("read_x_post")
       ? [{
           type: "function",
-          function: readXhsProfileFunctionSchema,
+          function: readXPostFunctionSchema,
         }]
       : []),
     ...tableTools,
@@ -555,15 +686,7 @@ function buildServerPlatformToolExecutors(args: {
       },
     ]),
   );
-  return {
-    taskRun: async (call: any) => {
-      return {
-        content: await postServer("/api/task-run", parseNoloWorkspaceToolArguments(call.arguments)),
-        metadata: { serverPlatformTool: true },
-      };
-    },
-    ...tableExecutors,
-  };
+  return tableExecutors;
 }
 
 function buildLocalToolExecutors(args: {
@@ -571,34 +694,11 @@ function buildLocalToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+  readXPost?: CliLocalRuntimeAdapterDeps["readXPost"];
   readXhsProfile?: CliLocalRuntimeAdapterDeps["readXhsProfile"];
   commandTimeoutMs?: number;
   commandOutputLimit?: number;
 }) {
-  const resolveCliDefaultXhsArgs = (parsedArgs: any) => {
-    if (
-      parsedArgs?.profileDir ||
-      parsedArgs?.profile_dir ||
-      args.env.NOLO_XHS_READER_PROFILE_DIR
-    ) {
-      return parsedArgs;
-    }
-    return {
-      ...parsedArgs,
-      profileDir: resolveDefaultXhsProfileDir({
-        env: {
-          ...process.env,
-          ...args.env,
-          NOLO_DESKTOP: "1",
-          NOLO_DESKTOP_CHANNEL:
-            args.env.NOLO_DESKTOP_CHANNEL?.trim() ||
-            args.env.NOLO_XHS_READER_DESKTOP_CHANNEL?.trim() ||
-            "stable",
-        },
-      }),
-    };
-  };
-
   return {
     ...createLocalWorkspaceToolExecutors({
       workspaceRoot: args.workspaceRoot,
@@ -612,12 +712,28 @@ function buildLocalToolExecutors(args: {
     ...buildCliWorkspaceToolExecutors({
       env: args.env,
     }),
+    read_x_post: async (call: any) => {
+      const parsedArgs = (() => {
+        try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
+      })();
+      const result = await (args.readXPost ?? readXPostFunc)(
+        parsedArgs,
+        undefined,
+      );
+      return {
+        content: JSON.stringify(result.rawData),
+        metadata: {
+          xPostLocalBridge: true,
+          displayData: result.displayData,
+        },
+      };
+    },
     read_xhs_profile: async (call: any) => {
       const parsedArgs = (() => {
         try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
       })();
       const result = await (args.readXhsProfile ?? readXhsProfileFunc)(
-        resolveCliDefaultXhsArgs(parsedArgs),
+        parsedArgs,
         undefined,
       );
       return {
@@ -713,6 +829,7 @@ export function createCliLocalRuntimeAdapter(
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
+    readXPost: deps.readXPost,
     readXhsProfile: deps.readXhsProfile,
     ...runtimeToolExecutionLimits,
   });
@@ -721,16 +838,22 @@ export function createCliLocalRuntimeAdapter(
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
+      const storedAgentConfig = await readAgentFromStore({
+        agentRef,
+        store: await resolveStore(deps),
+        userId,
+      });
+      const fallbackLocalCliAgentConfig =
+        storedAgentConfig ? null : resolveBuiltinLocalCliAgentConfig(agentRef, userId);
       const agentConfig = withResolvedRuntimeToolSurface(
-        await readAgentFromStore({
-          agentRef,
-          store: await resolveStore(deps),
-          userId,
-        }),
+        storedAgentConfig ?? fallbackLocalCliAgentConfig,
         deps.env
       );
       const requestedToolNames = agentConfig
-        ? resolveRequestedRuntimeToolNames({ agentConfig })
+        ? addDefaultLightWebToolsForConfiguredAgents(
+            resolveRequestedRuntimeToolNames({ agentConfig }),
+            agentConfig,
+          )
         : [];
       activeAgentToolNames = buildLocalPolicyToolNames({
         toolNames: requestedToolNames,
@@ -744,6 +867,7 @@ export function createCliLocalRuntimeAdapter(
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
+        readXPost: deps.readXPost,
         readXhsProfile: deps.readXhsProfile,
         ...runtimeToolExecutionLimits,
       });
@@ -828,9 +952,10 @@ export function createCliLocalRuntimeAdapter(
         return {
           model: providerConfig.model,
           complete: async (messages, options) => {
-            const requestedToolNames = resolveRequestedRuntimeToolNames({
+            const requestedToolNames = addDefaultLightWebToolsForConfiguredAgents(
+              resolveRequestedRuntimeToolNames({ agentConfig }),
               agentConfig,
-            });
+            );
             const tools = buildOpenAiTools({
               agentKey: agentConfig.key,
               toolNames: requestedToolNames,
@@ -901,9 +1026,10 @@ export function createCliLocalRuntimeAdapter(
       return {
         model: providerConfig.model,
         complete: async (messages, options) => {
-          const requestedToolNames = resolveRequestedRuntimeToolNames({
+          const requestedToolNames = addDefaultLightWebToolsForConfiguredAgents(
+            resolveRequestedRuntimeToolNames({ agentConfig }),
             agentConfig,
-          });
+          );
           const tools = buildOpenAiTools({
             agentKey: agentConfig.key,
             toolNames: requestedToolNames,

package/cli/commandRegistry.ts

@@ -14,6 +14,7 @@ export const COMMANDS: CommandEntry[] = [
 ];
 
 export const GROUP_ORDER = [
+  "run",
   "chat",
   "doc",
   "skill-doc",
@@ -21,9 +22,9 @@ export const GROUP_ORDER = [
   "agent",
   "doctor",
   "dialog",
+  "memory",
   "space",
   "table",
-  "task-run",
   "llama",
   "model-runtime",
   "dev",
@@ -55,23 +56,25 @@ export function renderHelpText() {
     "  nolo doctor",
     "  nolo doctor runtime",
     "  nolo update",
+    '  nolo run "review this repository"  # no Nolo login required; uses local Codex CLI',
     '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
     '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
     "  nolo agent list --json",
     "  nolo space list --json",
     "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
-    "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
-    '  nolo agent run frontend-implementer --msg "polish notifications"',
+  "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
+    "  nolo agent usage qoder",
+  '  nolo agent run frontend-implementer --msg "polish notifications"',
     "  nolo agent bind-current agent-user-1-agent-1",
     "  nolo agent runtime-doctor agent-user-1-agent-1",
     '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
     '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
+    "  nolo memory delete --source-dialog 01ABC... --yes --json",
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table query --table 01ABCXYZ",
     '  nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
     '  nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
-    "  nolo task-run read-context --row-dbkey row-user-table-row",
     "  nolo llama status",
   ];
 

package/cli/dialogAttachmentCleanup.ts

@@ -0,0 +1,151 @@
+import { deleteDbRecordOnServers, readDbRecordFromServers, type GlobalDeleteResult } from "./globalRecordOperations";
+import {
+  buildDialogAttachmentPlan,
+  extractFileContentIds,
+  type DialogAttachmentCandidate,
+  type DialogAttachmentPlan,
+} from "../chat/dialog/dialogAttachmentCleanup";
+
+export { buildDialogAttachmentPlan, extractFileContentIds };
+
+export type DialogAttachmentDeleteResult = {
+  fileId: string;
+  fileDbKey: string;
+  deleteResults: GlobalDeleteResult[];
+};
+
+function asText(value: unknown) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+async function readDialogMessages(args: {
+  authToken: string;
+  dialogId: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const response = await args.fetchImpl(`${args.serverUrl}/rpc/getConvMsgs`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ dialogId: args.dialogId, limit: 10000 }),
+  });
+  if (!response.ok) {
+    throw new Error(`read dialog messages failed on ${args.serverUrl}: HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  return Array.isArray(payload) ? payload : [];
+}
+
+export async function planDialogAttachmentCleanup(args: {
+  authToken: string;
+  dialogId: string;
+  ownerId?: string | null;
+  includeUserOwnedReferenced?: boolean;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  serverUrls: string[];
+}): Promise<DialogAttachmentPlan> {
+  const messages = await readDialogMessages({
+    authToken: args.authToken,
+    dialogId: args.dialogId,
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.serverUrl,
+  });
+  const fileIds = [...new Set(messages.flatMap((message) => extractFileContentIds(message)))];
+  const metadataByFileId: Record<string, any> = {};
+  const metadataReadFailures: Array<{ fileId: string; error: string }> = [];
+
+  for (const fileId of fileIds) {
+    try {
+      const result = await readDbRecordFromServers({
+        authToken: args.authToken,
+        dbKey: `file-id-${fileId}`,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrls: args.serverUrls,
+        label: `file metadata index ${fileId}`,
+      });
+      const mainKey = asText(result.record?.mainKey);
+      if (!mainKey) throw new Error(`file-id index missing mainKey`);
+      const metadata = await readDbRecordFromServers({
+        authToken: args.authToken,
+        dbKey: mainKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrls: args.serverUrls,
+        label: `file metadata ${fileId}`,
+      });
+      metadataByFileId[fileId] = {
+        ...metadata.record,
+        dbKey: asText(metadata.record?.dbKey) ?? mainKey,
+      };
+    } catch (error) {
+      const fallbackKey =
+        args.ownerId && !fileId.startsWith("file-")
+          ? `file-${args.ownerId}-${fileId}`
+          : null;
+      if (fallbackKey) {
+        try {
+          const metadata = await readDbRecordFromServers({
+            authToken: args.authToken,
+            dbKey: fallbackKey,
+            fallbackFetchImpl: args.fallbackFetchImpl,
+            fetchImpl: args.fetchImpl,
+            serverUrls: args.serverUrls,
+            label: `file metadata ${fileId}`,
+          });
+          metadataByFileId[fileId] = {
+            ...metadata.record,
+            dbKey: asText(metadata.record?.dbKey) ?? fallbackKey,
+          };
+          continue;
+        } catch {
+          // Keep the original index error; it explains why the preferred path failed.
+        }
+      }
+      metadataReadFailures.push({
+        fileId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return buildDialogAttachmentPlan({
+    dialogId: args.dialogId,
+    ownerId: args.ownerId,
+    includeUserOwnedReferenced: args.includeUserOwnedReferenced,
+    messages,
+    metadataByFileId,
+    metadataReadFailures,
+  });
+}
+
+export async function deleteDialogAttachmentCandidates(args: {
+  authToken: string;
+  candidates: DialogAttachmentCandidate[];
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrls: string[];
+}): Promise<DialogAttachmentDeleteResult[]> {
+  const results: DialogAttachmentDeleteResult[] = [];
+  for (const candidate of args.candidates) {
+    if (candidate.status !== "delete" || !candidate.fileDbKey) continue;
+    const deleteResults = await deleteDbRecordOnServers({
+      authToken: args.authToken,
+      dbKey: candidate.fileDbKey,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrls: args.serverUrls,
+    });
+    results.push({
+      fileId: candidate.fileId,
+      fileDbKey: candidate.fileDbKey,
+      deleteResults,
+    });
+  }
+  return results;
+}