memorylake-openclaw 1.1.2 → 1.1.4

package/lib/hooks/auto-recall.ts

@@ -1,89 +0,0 @@
-import type { PluginContext } from "../plugin-context";
-import type { OpenDataIndustry } from "../types";
-import { getProvider } from "../provider";
-
-const sessionIndustriesCache = new Map<string, OpenDataIndustry[]>();
-
-export const MEMORYLAKE_REMINDER = [
-  `[MEMORYLAKE REMINDER] Before responding to this message, call \`retrieve_context\` first`,
-  `to fetch relevant memories and documents. Do not skip this step.`,
-].join(" ");
-
-export function registerAutoRecall(pctx: PluginContext): void {
-  const { api, resolveConfig } = pctx;
-
-  api.on("before_prompt_build", async (event, ctx) => {
-    if ((ctx as any)?.trigger !== "user") {
-      api.logger.info(`memorylake-openclaw: auto-recall skipped, trigger=${(ctx as any)?.trigger ?? "undefined"}`);
-      return;
-    }
-    if (!event.prompt) return;
-
-    const effectiveCfg = resolveConfig(ctx);
-    const effectiveProvider = getProvider(effectiveCfg);
-
-    const sessionId = (ctx as any)?.sessionId ?? undefined;
-
-    // Fetch industries once per session, then cache
-    let industries: OpenDataIndustry[] | undefined;
-    if (sessionId && sessionIndustriesCache.has(sessionId)) {
-      industries = sessionIndustriesCache.get(sessionId);
-    } else {
-      try {
-        const projectInfo = await effectiveProvider.getProject();
-        industries = projectInfo.industries;
-        if (sessionId) {
-          sessionIndustriesCache.set(sessionId, industries);
-        }
-      } catch (err) {
-        api.logger.warn(`memorylake-openclaw: project info fetch failed: ${String(err)}`);
-      }
-    }
-
-    const result: { prependContext?: string; prependSystemContext?: string; appendSystemContext?: string } = {};
-
-    // Per-turn reminder injected right before the user's message.
-    // Survives long conversations because it is not buried in the system prompt.
-    result.prependContext = MEMORYLAKE_REMINDER;
-
-    const memoryDirectiveParts: string[] = [
-      `<memory-instructions>`,
-      `You have access to the user's long-term memory AND documents via MemoryLake (retrieve_context tool).`,
-      `The retrieve_context tool searches both memories and uploaded documents in a single call.`,
-      ``,
-      `MANDATORY PROCEDURE — applies to EVERY user message, including follow-ups in multi-turn conversations:`,
-      `1. BEFORE generating any text, call retrieve_context with a query derived from the current message.`,
-      `2. Use the search results (memories + documents) to personalize your response.`,
-      `3. Respond to the user.`,
-      ``,
-      `COMMON MISTAKES TO AVOID:`,
-      `- Searching only at the start of a conversation and skipping subsequent messages — WRONG.`,
-      `- Seeing a task-oriented message (e.g. "check weather", "translate this") and skipping retrieve_context — WRONG.`,
-      `- Deciding retrieve_context is "not useful" for this particular message — WRONG. Always search.`,
-      `- Generating any text response before calling retrieve_context — WRONG.`,
-      ``,
-      `The rule is absolute: retrieve_context FIRST, then respond. Every message. No exceptions.`,
-      `</memory-instructions>`,
-    ];
-    result.prependSystemContext = memoryDirectiveParts.join("\n");
-
-    const appendParts: string[] = [];
-    if (industries && industries.length > 0) {
-      const categoryList = industries
-        .map((ind) => `- ${ind.id}: ${ind.name}${ind.description ? ` — ${ind.description}` : ""}`)
-        .join("\n");
-      appendParts.push(
-        `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`,
-      );
-      api.logger.info(
-        `memorylake-openclaw: injecting ${industries.length} open data categories into system context`,
-      );
-    }
-
-    if (appendParts.length > 0) {
-      result.appendSystemContext = appendParts.join("\n\n");
-    }
-
-    return result;
-  });
-}

package/lib/hooks/auto-upload.ts

@@ -1,72 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { PluginContext } from "../plugin-context";
-import type { UploadFn } from "../types";
-import { getUploadedRecord, saveUploadedRecord, needsUpload, extractInboundPaths } from "../helpers/upload-record";
-
-export function registerAutoUpload(pctx: PluginContext): void {
-  const { api, resolveConfig } = pctx;
-
-  // Lazy-load upload function from upload.mjs
-  let uploadAutoFn: UploadFn | undefined;
-
-  api.on("before_prompt_build", (event, ctx) => {
-    if ((ctx as any)?.trigger !== "user") {
-      api.logger.info(`memorylake-openclaw: auto-upload skipped, trigger=${(ctx as any)?.trigger ?? "undefined"}`);
-      return;
-    }
-    const workspaceDir = (ctx as any)?.workspaceDir;
-    if (!workspaceDir || !event.prompt) return;
-
-    const effectiveCfg = resolveConfig(ctx);
-    const paths = extractInboundPaths(event.prompt);
-    if (paths.length === 0) return;
-
-    const record = getUploadedRecord(workspaceDir);
-    const filesToUpload: { filePath: string; stat: fs.Stats }[] = [];
-    for (const p of paths) {
-      const stat = needsUpload(record, p);
-      if (stat) filesToUpload.push({ filePath: p, stat });
-    }
-    if (filesToUpload.length === 0) return;
-
-    // Fire-and-forget: upload asynchronously without blocking
-    (async () => {
-      // Lazy import upload.mjs
-      if (!uploadAutoFn) {
-        const uploadModule = await import(
-          /* webpackIgnore: true */
-          new URL("../../skills/memorylake-upload/scripts/upload.mjs", import.meta.url).href
-        );
-        uploadAutoFn = uploadModule.uploadAuto;
-      }
-
-      for (const { filePath, stat } of filesToUpload) {
-        try {
-          await uploadAutoFn!({
-            host: effectiveCfg.host,
-            apiKey: effectiveCfg.apiKey,
-            projectId: effectiveCfg.projectId,
-            filePath,
-            fileName: path.basename(filePath),
-          });
-          // Save record only after successful upload to avoid race on crash
-          const current = getUploadedRecord(workspaceDir);
-          current[filePath] = { mtimeMs: stat.mtimeMs };
-          saveUploadedRecord(workspaceDir, current);
-          api.logger.info(
-            `memorylake-openclaw: auto-uploaded ${path.basename(filePath)}`,
-          );
-        } catch (err) {
-          api.logger.warn(
-            `memorylake-openclaw: auto-upload failed for ${filePath}: ${String(err)}`,
-          );
-        }
-      }
-    })().catch((err) => {
-      api.logger.warn(
-        `memorylake-openclaw: auto-upload unexpected error: ${String(err)}`,
-      );
-    });
-  });
-}

package/lib/plugin-context.ts

@@ -1,77 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type { MemoryLakeConfig } from "./types";
-import { ALLOWED_KEYS, memoryLakeConfigSchema } from "./config";
-import { readJson5ConfigFile } from "./utils/config-parser";
-
-const PLUGIN_ID = "memorylake-openclaw";
-const GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
-
-/**
- * Read and parse the plugin config from the global openclaw.json.
- * Returns a fully parsed MemoryLakeConfig, or null if the file is
- * unreadable, missing, or the plugin section is absent/invalid.
- */
-function readGlobalConfig(logger: OpenClawPluginApi["logger"]): MemoryLakeConfig | null {
-  try {
-    const raw = readJson5ConfigFile(GLOBAL_CONFIG_PATH) as any;
-    const pluginCfg = raw?.plugins?.entries?.[PLUGIN_ID]?.config;
-    if (!pluginCfg) {
-      logger.info(`memorylake-openclaw: no plugin config found in global config (path: ${GLOBAL_CONFIG_PATH}, pluginId: ${PLUGIN_ID})`);
-      return null;
-    }
-    return memoryLakeConfigSchema.parse(pluginCfg);
-  } catch (err) {
-    logger.warn(`memorylake-openclaw: failed to read or parse global config (path: ${GLOBAL_CONFIG_PATH}): ${String(err)}`);
-    return null;
-  }
-}
-
-export interface PluginContext {
-  api: OpenClawPluginApi;
-  resolveConfig: (ctx: any) => MemoryLakeConfig;
-}
-
-export function createPluginContext(api: OpenClawPluginApi, initialCfg: MemoryLakeConfig): PluginContext {
-
-  function resolveConfig(ctx: any): MemoryLakeConfig {
-    // Re-read global config on every call so changes take effect without restart
-    const globalCfg = readGlobalConfig(api.logger) ?? initialCfg;
-
-    const workspaceDir = ctx?.workspaceDir;
-    if (!workspaceDir) return globalCfg;
-
-    const localPath = path.join(workspaceDir, ".memorylake", "config.json");
-    if (!fs.existsSync(localPath)) return globalCfg;
-
-    try {
-      const raw = JSON.parse(fs.readFileSync(localPath, "utf-8"));
-      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        api.logger.warn(
-          `memorylake-openclaw: workspace config exists but is not a JSON object; falling back to global config (path: ${localPath})`,
-        );
-        return globalCfg;
-      }
-
-      const allowed = new Set(ALLOWED_KEYS);
-      const overrides: Record<string, unknown> = {};
-      for (const [key, value] of Object.entries(raw)) {
-        if (allowed.has(key)) overrides[key] = value;
-      }
-
-      return { ...globalCfg, ...overrides } as MemoryLakeConfig;
-    } catch (err) {
-      api.logger.warn(
-        `memorylake-openclaw: failed to parse workspace config JSON; falling back to global config (path: ${localPath}): ${String(err)}`,
-      );
-      return globalCfg;
-    }
-  }
-
-  return {
-    api,
-    resolveConfig,
-  };
-}

package/lib/prompt/register-prompt.ts

@@ -1,66 +0,0 @@
-import type { PluginContext } from "../plugin-context";
-import type { MemoryLakeConfig } from "../types";
-
-export function registerMemoryPromptSection(pctx: PluginContext, cfg: MemoryLakeConfig): void {
-  pctx.api.registerMemoryPromptSection((params) => {
-    const lines: string[] = [
-      cfg.autoRecall ? "## Memory (MANDATORY — MemoryLake)" : "## Memory (MemoryLake)",
-      "",
-      "You have access to MemoryLake, a long-term memory system that stores the user's preferences, history, personal context, and uploaded documents across sessions.",
-      "",
-    ];
-
-    if (params.availableTools.has("retrieve_context")) {
-      if (cfg.autoRecall) {
-        lines.push(
-          "### retrieve_context — MUST be your FIRST action for EVERY message",
-          "",
-          "**RULE: Before generating ANY text, call `retrieve_context` first.** This is mandatory for EVERY user message in the conversation — the 1st, 2nd, 5th, 20th, every single one.",
-          "",
-          "This tool searches BOTH memories AND documents in one call.",
-          "",
-          "This applies to ALL types of messages:",
-          "- Greetings -> search for who the user is",
-          "- Recommendations (books, activities, food) -> search for preferences",
-          "- Tasks (check weather, translate, write email) -> search for user context",
-          "- Follow-up questions in the same conversation -> search again with new query",
-          "- Document questions -> search for uploaded document content",
-          "- ANY other message -> search for relevant context",
-          "",
-          "**WRONG behavior (do NOT do this):**",
-          "- Searching only on the first message, then skipping for the rest of the conversation",
-          "- Deciding a message does not need memory context and skipping the search",
-          "- Responding first, then searching (or not searching at all)",
-          "",
-          "**CORRECT behavior:**",
-          "- Every message -> retrieve_context -> then respond. Always. No thinking about whether to skip.",
-          "",
-        );
-      } else {
-        lines.push(
-          "### retrieve_context",
-          "- Use `retrieve_context` to search the user's long-term memories and uploaded documents when relevant context may help your response.",
-          "",
-        );
-      }
-    }
-
-    if (params.availableTools.has("memory_list")) {
-      lines.push(
-        "### memory_list",
-        "- When the user asks what you remember or wants to see all stored memories, call `memory_list`.",
-        "",
-      );
-    }
-
-    if (params.availableTools.has("memory_forget")) {
-      lines.push(
-        "### memory_forget",
-        "- When the user explicitly asks to delete or forget a specific memory, call `memory_forget` with the memory ID.",
-        "",
-      );
-    }
-
-    return lines;
-  });
-}

package/lib/provider.ts

@@ -1,227 +0,0 @@
-import got from "got";
-import type { MemoryLakeConfig, AddOptions, SearchOptions, ListOptions, MemoryItem, AddResult, DocumentSearchResponse, WebSearchOptions, WebSearchResponse, OpenDataSearchOptions, OpenDataSearchResponse, ProjectInfo, ConflictItem, ConflictListResponse, MemoryLakeProvider } from "./types";
-import { normalizeMemoryItem, normalizeSearchResults, normalizeAddResult, normalizeWebSearchResponse, normalizeOpenDataSearchResponse, normalizeWebSearchDomain, normalizeOpenDataCategory } from "./utils/normalizers";
-
-interface ApiResponse<T = unknown> {
-  success: boolean;
-  message?: string;
-  data?: T;
-  error_code?: string;
-}
-
-export class PlatformProvider implements MemoryLakeProvider {
-  private readonly http: ReturnType<typeof got.extend>;
-  private readonly basePath: string;
-  private readonly docSearchPath: string;
-  private readonly webSearchPath: string;
-  private readonly openDataSearchPath: string;
-  private readonly projectPath: string;
-  private readonly conflictsPath: string;
-  private readonly projectId: string;
-
-  constructor(host: string, apiKey: string, projectId: string) {
-    this.projectId = projectId;
-    this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
-    this.docSearchPath = `openapi/memorylake/api/v1/projects/${projectId}/documents/search`;
-    this.webSearchPath = "openapi/memorylake/api/v1/search";
-    this.openDataSearchPath = "openapi/memorylake/api/v1/search/opendata";
-    this.projectPath = `openapi/memorylake/api/v1/projects/${projectId}`;
-    this.conflictsPath = `openapi/memorylake/api/v2/projects/${projectId}/memories/conflicts`;
-    this.http = got.extend({
-      prefixUrl: host,
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-      responseType: "json",
-    });
-  }
-
-  async add(
-    messages: Array<{ role: string; content: string }>,
-    options: AddOptions,
-  ): Promise<AddResult> {
-    const body: Record<string, unknown> = {
-      messages,
-      user_id: options.user_id,
-      infer: options.infer ?? true,
-    };
-    if (options.chat_session_id) body.chat_session_id = options.chat_session_id;
-    if (options.metadata) body.metadata = options.metadata;
-
-    const resp = await this.http
-      .post(this.basePath, { json: body })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "add failed");
-    return normalizeAddResult(resp.data);
-  }
-
-  async search(query: string, options: SearchOptions): Promise<MemoryItem[]> {
-    const body: Record<string, unknown> = {
-      query,
-      user_id: options.user_id,
-      with_conflicts: true,
-    };
-    if (options.top_k != null) body.top_k = options.top_k;
-    if (options.threshold != null) body.threshold = options.threshold;
-    if (options.rerank != null) body.rerank = options.rerank;
-
-
-    const resp = await this.http
-      .post(`${this.basePath}/search`, { json: body })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "search failed");
-
-    return normalizeSearchResults(resp.data);
-  }
-
-  async get(memoryId: string): Promise<MemoryItem> {
-    const resp = await this.http
-      .get(`${this.basePath}/${memoryId}`)
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "get failed");
-    return normalizeMemoryItem(resp.data);
-  }
-
-  async getAll(options: ListOptions): Promise<MemoryItem[]> {
-    const searchParams: Record<string, string | number> = {};
-    if (options.user_id) searchParams.user_id = options.user_id;
-    if (options.page != null) searchParams.page = options.page;
-    if (options.size != null) searchParams.size = options.size;
-
-    const resp = await this.http
-      .get(this.basePath, { searchParams })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "getAll failed");
-    const data = resp.data as any;
-    if (data?.items && Array.isArray(data.items))
-      return data.items.map(normalizeMemoryItem);
-    return [];
-  }
-
-  async delete(memoryId: string): Promise<void> {
-    const resp = await this.http
-      .delete(`${this.basePath}/${memoryId}`)
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "delete failed");
-  }
-
-  async searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse> {
-    const resp = await this.http
-      .post(this.docSearchPath, { json: { query, top_N: topN } })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "document search failed");
-    const data = resp.data as any;
-    return {
-      count: data?.count ?? 0,
-      results: Array.isArray(data?.results) ? data.results : [],
-    };
-  }
-
-  async getDocumentDownloadUrl(documentId: string): Promise<string> {
-    const downloadPath = `openapi/memorylake/api/v1/projects/${this.projectId}/documents/${documentId}/download`;
-    const resp = await this.http.get(downloadPath, {
-      followRedirect: false,
-      responseType: "text" as any,
-      throwHttpErrors: false,
-    });
-    if (resp.statusCode === 303 || resp.statusCode === 302) {
-      const location = resp.headers.location;
-      if (!location) throw new Error("Download redirect missing Location header");
-      return location;
-    }
-    if (resp.statusCode === 404) {
-      throw new Error(`Document not found: ${documentId}`);
-    }
-    throw new Error(`Unexpected download response status: ${resp.statusCode}`);
-  }
-
-  async searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse> {
-    const domain = options.domain != null ? normalizeWebSearchDomain(options.domain) : "web";
-    const body: Record<string, unknown> = {
-      query,
-      domain,
-    };
-    if (options.max_results != null) body.max_results = options.max_results;
-    if (options.start_date) body.start_date = options.start_date;
-    if (options.end_date) body.end_date = options.end_date;
-    if (options.include_domains?.length) body.include_domains = options.include_domains;
-    if (options.exclude_domains?.length) body.exclude_domains = options.exclude_domains;
-    if (options.user_location) body.user_location = options.user_location;
-
-    const resp = await this.http
-      .post(this.webSearchPath, { json: body })
-      .json<WebSearchResponse>();
-    return normalizeWebSearchResponse(resp);
-  }
-
-  async searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse> {
-    const body: Record<string, unknown> = { query };
-    if (options.dataset != null) {
-      const ds = normalizeOpenDataCategory(options.dataset);
-      if (!ds) throw new Error(`Invalid open data dataset: "${options.dataset}"`);
-      body.dataset = ds;
-    }
-    if (options.max_results != null) body.max_results = options.max_results;
-    if (options.start_date) body.start_date = options.start_date;
-    if (options.end_date) body.end_date = options.end_date;
-
-    const resp = await this.http
-      .post(this.openDataSearchPath, { json: body })
-      .json<OpenDataSearchResponse>();
-    return normalizeOpenDataSearchResponse(resp);
-  }
-
-  async getProject(): Promise<ProjectInfo> {
-    const resp = await this.http
-      .get(this.projectPath)
-      .json<ApiResponse<{ id?: string; name?: string; description?: string; industries?: Array<{ id?: string; name?: string; description?: string }> }>>();
-    if (!resp.success) throw new Error(resp.message ?? "get project failed");
-    const data = resp.data;
-    const info: ProjectInfo = {
-      id: data?.id ?? "",
-      name: data?.name ?? "",
-      description: data?.description,
-      industries: Array.isArray(data?.industries)
-        ? data.industries.map((ind) => ({
-            id: ind.id ?? "",
-            name: ind.name ?? "",
-            description: ind.description,
-          }))
-        : [],
-    };
-    return info;
-  }
-
-  async listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]> {
-    if (memoryIds.length === 0) return [];
-    const searchParams: Record<string, string> = {
-      resolved: "false",
-      memory_ids: memoryIds.join(","),
-    };
-    const resp = await this.http
-      .get(this.conflictsPath, {
-        searchParams
-      })
-      .json<ApiResponse<ConflictListResponse>>();
-    if (!resp.success) throw new Error(resp.message ?? "list conflicts failed");
-    const data = resp.data;
-    return Array.isArray(data?.items) ? data.items : [];
-  }
-
-}
-
-// ============================================================================
-// Provider Cache
-// ============================================================================
-
-const providerCache = new Map<string, MemoryLakeProvider>();
-
-export function getProvider(effectiveCfg: MemoryLakeConfig): MemoryLakeProvider {
-  const key = `${effectiveCfg.host}|${effectiveCfg.apiKey}|${effectiveCfg.projectId}`;
-  let p = providerCache.get(key);
-  if (!p) {
-    p = new PlatformProvider(effectiveCfg.host, effectiveCfg.apiKey, effectiveCfg.projectId);
-    providerCache.set(key, p);
-  }
-  return p;
-}

package/lib/tools/document-tools.ts

@@ -1,100 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import got from "got";
-import { pipeline } from "node:stream/promises";
-import { Type } from "@sinclair/typebox";
-import type { PluginContext } from "../plugin-context";
-import { getProvider } from "../provider";
-import { parseContentDispositionFilename } from "../helpers/parse-content-disposition";
-
-export function registerDocumentTools(pctx: PluginContext): void {
-  const { api, resolveConfig } = pctx;
-
-  api.registerTool(
-    (ctx) => ({
-      name: "document_download",
-      label: "Document Download",
-      description:
-        "Download a document (image, PDF, etc.) from MemoryLake to local disk. After calling this tool, you MUST call the `message` tool with action='send' and media=<the returned local file path> to deliver the file to the user.",
-      parameters: Type.Object({
-        documentId: Type.String({
-          description:
-            "The document ID to download (from retrieve_context results or document listing)",
-        }),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const { documentId } = params as { documentId: string };
-
-        try {
-          // 1. Get pre-signed download URL (API returns 303 redirect to object storage)
-          const downloadUrl =
-            await effectiveProvider.getDocumentDownloadUrl(documentId);
-
-          // 2. Determine local save directory (cross-platform)
-          const workspaceDir = (ctx as any)?.workspaceDir;
-          const downloadDir = workspaceDir
-            ? path.join(workspaceDir, ".memorylake", "downloads")
-            : path.join(os.tmpdir(), "memorylake-downloads");
-          fs.mkdirSync(downloadDir, { recursive: true });
-
-          // 3. Download file to a temp path and extract filename from the
-          //    object storage response's Content-Disposition header.
-          //    The API redirect URL includes a `response-content-disposition` query
-          //    param which instructs object storage to return the header with the
-          //    original filename — this is the sole reliable source of the filename.
-          const tempPath = path.join(downloadDir, `.dl-${documentId}.tmp`);
-          let cdFileName: string | null = null;
-          const stream = got.stream(downloadUrl);
-          stream.on("response", (resp: any) => {
-            cdFileName = parseContentDispositionFilename(
-              resp.headers?.["content-disposition"],
-            );
-          });
-          await pipeline(stream, fs.createWriteStream(tempPath));
-
-          // 4. Use Content-Disposition filename; fall back to documentId if absent
-          const finalName = cdFileName || documentId;
-
-          // 5. Resolve filename collisions by appending a numeric suffix
-          let localPath = path.join(downloadDir, finalName);
-          if (fs.existsSync(localPath)) {
-            const ext = path.extname(finalName);
-            const base = finalName.slice(0, finalName.length - ext.length);
-            let counter = 1;
-            while (fs.existsSync(localPath)) {
-              localPath = path.join(downloadDir, `${base}-${counter}${ext}`);
-              counter++;
-            }
-          }
-
-          // 6. Rename temp to final name
-          fs.renameSync(tempPath, localPath);
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Document ${documentId} downloaded to:\n${localPath}\n\nYou MUST now call the message tool with action="send" and media set to this local path to deliver the file to the user.`,
-              },
-            ],
-            details: { documentId, localPath },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Document download failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-    { name: "document_download" },
-  );
-}