memorylake-openclaw 1.1.3 → 1.1.4

package/lib/tools/memory-tools.ts

@@ -1,298 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { PluginContext } from "../plugin-context";
-import type { MemoryLakeConfig } from "../types";
-import { getProvider } from "../provider";
-import { buildDocumentContext, buildConflictContext, buildAddOptions, buildSearchOptions } from "../utils/builders";
-
-export function registerMemoryTools(pctx: PluginContext, cfg: MemoryLakeConfig): void {
-  const { api, resolveConfig } = pctx;
-
-  // retrieve_context
-  api.registerTool(
-    (ctx) => ({
-      name: "retrieve_context",
-      label: "Retrieve Context",
-      description: cfg.autoRecall
-        ? "MANDATORY — call this tool BEFORE responding to EVERY user message (not just the first). Searches long-term memories AND uploaded documents in MemoryLake. Returns the user's context, preferences, history, and relevant document content. Never skip this step, even for follow-up messages or task-oriented requests."
-        : "Search long-term memories and uploaded documents in MemoryLake. Returns the user's context, preferences, history, and relevant document content.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query" }),
-        limit: Type.Optional(
-          Type.Number({
-            description: `Max results (default: ${cfg.topK})`,
-          }),
-        ),
-        userId: Type.Optional(
-          Type.String({
-            description:
-              "User ID to scope search (default: configured userId)",
-          }),
-        ),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const { query, limit, userId } = params as {
-          query: string;
-          limit?: number;
-          userId?: string;
-        };
-
-        const [memoryResult, docResult] = await Promise.allSettled([
-          effectiveProvider.search(
-            query,
-            buildSearchOptions(effectiveCfg, userId, limit),
-          ),
-          effectiveProvider.searchDocuments(query, effectiveCfg.topK),
-        ]);
-
-        const sections: string[] = [];
-        let memoryCount = 0;
-        let docCount = 0;
-        let sanitizedMemories: { id: string; content: string; created_at: string }[] = [];
-
-        if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-          const results = memoryResult.value;
-          memoryCount = results.length;
-          const text = results
-            .map((r, i) => `${i + 1}. ${r.content} (id: ${r.id})`)
-            .join("\n");
-          sections.push(`## Memories\nFound ${results.length} memories:\n\n${text}`);
-          sanitizedMemories = results.map((r) => ({
-            id: r.id,
-            content: r.content,
-            created_at: r.created_at,
-          }));
-
-          // Check for unresolved conflicts among returned memories
-          const conflictMemoryIds = results
-            .filter((r) => r.has_unresolved_conflict)
-            .map((r) => r.id);
-          if (conflictMemoryIds.length > 0) {
-            try {
-              const effectiveUserId = userId ?? effectiveCfg.userId;
-              const conflicts = await effectiveProvider.listConflicts(conflictMemoryIds, effectiveUserId);
-              if (conflicts.length > 0) {
-                const conflictText = buildConflictContext(conflicts);
-                sections.push(`## Memory Conflicts\nThe following memories have unresolved conflicts. Review and help the user resolve them if relevant:\n\n${conflictText}`);
-              }
-            } catch (err) {
-              sections.push(`## Memory Conflicts\nFailed to fetch conflicts: ${String(err)}`);
-            }
-          }
-        } else if (memoryResult.status === "rejected") {
-          sections.push(`## Memories\nMemory search failed: ${String(memoryResult.reason)}`);
-        }
-
-        if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
-          docCount = docResult.value.results.length;
-          const context = buildDocumentContext(docResult.value.results);
-          sections.push(`## Documents\nFound ${docCount} document results:\n\n${context}`);
-        } else if (docResult.status === "rejected") {
-          sections.push(`## Documents\nDocument search failed: ${String(docResult.reason)}`);
-        }
-
-        if (memoryCount === 0 && docCount === 0) {
-          return {
-            content: [
-              { type: "text", text: "No relevant memories or documents found." },
-            ],
-            details: { memoryCount: 0, documentCount: 0, memories: [] },
-          };
-        }
-
-        return {
-          content: [
-            {
-              type: "text",
-              text: sections.join("\n\n"),
-            },
-          ],
-          details: {
-            memoryCount,
-            documentCount: docCount,
-            memories: sanitizedMemories,
-          },
-        };
-      },
-    }),
-    { name: "retrieve_context" },
-  );
-
-  // memory_store
-  api.registerTool(
-    (ctx) => ({
-      name: "memory_store",
-      label: "Memory Store",
-      description:
-        "Save important information in long-term memory via MemoryLake. Use for preferences, facts, decisions, and anything worth remembering.",
-      parameters: Type.Object({
-        text: Type.String({ description: "Information to remember" }),
-        userId: Type.Optional(
-          Type.String({
-            description: "User ID to scope this memory",
-          }),
-        ),
-        metadata: Type.Optional(
-          Type.Record(Type.String(), Type.Unknown(), {
-            description: "Optional metadata to attach to this memory",
-          }),
-        ),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const { text, userId } = params as {
-          text: string;
-          userId?: string;
-          metadata?: Record<string, unknown>;
-        };
-
-        try {
-          const result = await effectiveProvider.add(
-            [{ role: "user", content: text }],
-            buildAddOptions(effectiveCfg, userId, (ctx as any)?.sessionId),
-          );
-
-          const count = result.results?.length ?? 0;
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: count > 0
-                  ? `Submitted ${count} memory task(s) for processing. ${result.results.map((r) => `[${r.status}] ${r.message}`).join("; ")}`
-                  : "No memories extracted.",
-              },
-            ],
-            details: {
-              action: "stored",
-              results: result.results,
-            },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Memory store failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-    { name: "memory_store" },
-  );
-
-  // memory_list
-  api.registerTool(
-    (ctx) => ({
-      name: "memory_list",
-      label: "Memory List",
-      description:
-        "List all stored memories for a user. Use this when you want to see everything that's been remembered, rather than searching for something specific.",
-      parameters: Type.Object({
-        userId: Type.Optional(
-          Type.String({
-            description:
-              "User ID to list memories for (default: configured userId)",
-          }),
-        ),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const { userId } = params as { userId?: string };
-
-        try {
-          const uid = userId || effectiveCfg.userId;
-          const memories = await effectiveProvider.getAll({ user_id: uid });
-
-          if (!memories || memories.length === 0) {
-            return {
-              content: [
-                { type: "text", text: "No memories stored yet." },
-              ],
-              details: { count: 0 },
-            };
-          }
-
-          const text = memories
-            .map(
-              (r, i) =>
-                `${i + 1}. ${r.content} (id: ${r.id})`,
-            )
-            .join("\n");
-
-          const sanitized = memories.map((r) => ({
-            id: r.id,
-            content: r.content,
-            created_at: r.created_at,
-          }));
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `${memories.length} memories:\n\n${text}`,
-              },
-            ],
-            details: { count: memories.length, memories: sanitized },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Memory list failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-    { name: "memory_list" },
-  );
-
-  // memory_forget
-  api.registerTool(
-    (ctx) => ({
-      name: "memory_forget",
-      label: "Memory Forget",
-      description:
-        "Forget (delete) a specific memory by ID from MemoryLake.",
-      parameters: Type.Object({
-        memoryId: Type.String({ description: "Memory ID to delete" }),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const { memoryId } = params as { memoryId: string };
-
-        try {
-          await effectiveProvider.delete(memoryId);
-          return {
-            content: [
-              { type: "text", text: `Memory ${memoryId} forgotten.` },
-            ],
-            details: { action: "deleted", id: memoryId },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Memory forget failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-    { name: "memory_forget" },
-  );
-}

package/lib/tools/search-tools.ts

@@ -1,288 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import type { PluginContext } from "../plugin-context";
-import type { MemoryLakeConfig, WebSearchDomain } from "../types";
-import { OpenDataCategoryValues } from "../types";
-import { getProvider } from "../provider";
-import { normalizeWebSearchDomain, normalizeOpenDataCategory } from "../utils/normalizers";
-import { buildWebSearchContext, buildOpenDataContext } from "../utils/builders";
-
-export function registerSearchTools(pctx: PluginContext, cfg: MemoryLakeConfig): void {
-  const { api, resolveConfig } = pctx;
-
-  // advanced_web_search
-  api.registerTool(
-    (ctx) => ({
-      name: "advanced_web_search",
-      label: "Advanced Web Search",
-      description:
-        "Search the web using the unified search API with plugin-level domain and location constraints. Use this for recent information, public web pages, or web research that should respect configured allowed domains, blocked domains, and user locale.",
-      parameters: Type.Object({
-        query: Type.String({
-          description:
-            "The web search query to send to the unified search endpoint.",
-        }),
-        domain: Type.Optional(
-          Type.Union(
-            [
-              Type.Literal("web"),
-              Type.Literal("academic"),
-              Type.Literal("news"),
-              Type.Literal("people"),
-              Type.Literal("company"),
-              Type.Literal("financial"),
-              Type.Literal("markets"),
-              Type.Literal("code"),
-              Type.Literal("legal"),
-              Type.Literal("government"),
-              Type.Literal("poi"),
-              Type.Literal("auto"),
-            ],
-            {
-              description:
-                "Search domain. Default: web. Invalid or unknown values are treated as auto.",
-            },
-          ),
-        ),
-        maxResults: Type.Optional(
-          Type.Number({
-            description: `Maximum number of web results to return (default: ${cfg.topK}).`,
-            minimum: 1,
-          }),
-        ),
-        startDate: Type.Optional(
-          Type.String({
-            description:
-              "Only include results published on or after this date (YYYY-MM-DD).",
-          }),
-        ),
-        endDate: Type.Optional(
-          Type.String({
-            description:
-              "Only include results published on or before this date (YYYY-MM-DD).",
-          }),
-        ),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const {
-          query,
-          domain: rawDomain,
-          maxResults,
-          startDate,
-          endDate,
-        } = params as {
-          query: string;
-          domain?: string;
-          maxResults?: number;
-          startDate?: string;
-          endDate?: string;
-        };
-        const domain: WebSearchDomain =
-          rawDomain === undefined || rawDomain === null
-            ? "web"
-            : normalizeWebSearchDomain(rawDomain);
-
-        try {
-          const response = await effectiveProvider.searchWeb(query, {
-            domain,
-            max_results: maxResults ?? effectiveCfg.topK,
-            start_date: startDate,
-            end_date: endDate,
-            include_domains: effectiveCfg.webSearchIncludeDomains,
-            exclude_domains: effectiveCfg.webSearchExcludeDomains,
-            user_location:
-              effectiveCfg.webSearchCountry || effectiveCfg.webSearchTimezone
-                ? {
-                  country: effectiveCfg.webSearchCountry,
-                  timezone: effectiveCfg.webSearchTimezone,
-                }
-                : undefined,
-          });
-
-          if (!response.results || response.results.length === 0) {
-            return {
-              content: [
-                { type: "text", text: "No relevant web results found." },
-              ],
-              details: { count: 0, total_results: response.total_results },
-            };
-          }
-
-          const context = buildWebSearchContext(response.results);
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Found ${response.results.length} web results:\n\n${context}`,
-              },
-            ],
-            details: {
-              count: response.results.length,
-              total_results: response.total_results,
-              results: response.results,
-            },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Web search failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-    { optional: true },
-  );
-
-  // open_data_search
-  api.registerTool(
-    (ctx) => ({
-      name: "open_data_search",
-      label: "Open Data Search",
-      description:
-        "Search across open datasets routed to the appropriate proprietary data source based on the dataset:\n- research/academic: arXiv, PubMed, bioRxiv, medRxiv\n- clinical/trials: Clinical trial registries\n- drug/database: ChEMBL, DrugBank, PubChem, etc.\n- financial/markets: Stocks, crypto, forex, funds, commodities\n- company/fundamentals: SEC filings, earnings, balance sheets, etc.\n- economic/data: FRED, BLS, World Bank, etc.\n- patents/ip: USPTO patents",
-      parameters: Type.Object({
-        query: Type.String({
-          description: "The search query to send to the open data endpoint.",
-        }),
-        dataset: Type.Union(
-          [
-            Type.Literal("research/academic"),
-            Type.Literal("clinical/trials"),
-            Type.Literal("drug/database"),
-            Type.Literal("financial/markets"),
-            Type.Literal("company/fundamentals"),
-            Type.Literal("economic/data"),
-            Type.Literal("patents/ip"),
-          ],
-          {
-            description:
-              "Dataset category to search. Must be one of the project's enabled categories.",
-          },
-        ),
-        maxResults: Type.Optional(
-          Type.Number({
-            description: `Maximum number of results to return (default: ${cfg.topK}). The server enforces a hard cap.`,
-            minimum: 1,
-          }),
-        ),
-        startDate: Type.Optional(
-          Type.String({
-            description: "Only include results published on or after this date (YYYY-MM-DD).",
-          }),
-        ),
-        endDate: Type.Optional(
-          Type.String({
-            description: "Only include results published on or before this date (YYYY-MM-DD).",
-          }),
-        ),
-      }),
-      async execute(_toolCallId, params) {
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-        const {
-          query,
-          dataset: rawDataset,
-          maxResults,
-          startDate,
-          endDate,
-        } = params as {
-          query: string;
-          dataset: string;
-          maxResults?: number;
-          startDate?: string;
-          endDate?: string;
-        };
-
-        // Normalize once; use throughout to avoid casing bugs
-        const dataset = normalizeOpenDataCategory(rawDataset);
-
-        if (!dataset) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Unsupported dataset: "${rawDataset}". Supported values are: ${OpenDataCategoryValues.join(", ")}`,
-              },
-            ],
-            details: { error: "unsupported_dataset", dataset: rawDataset },
-          };
-        }
-
-        try {
-          // Validate dataset against project's allowed industries
-          const projectInfo = await effectiveProvider.getProject();
-          if (projectInfo.industries.length > 0) {
-            const allowedIds = projectInfo.industries.map((ind) => ind.id);
-            if (!allowedIds.includes(dataset)) {
-              const allowed = projectInfo.industries
-                .map((ind) => `${ind.id} (${ind.name})`)
-                .join(", ");
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Dataset "${dataset}" is not enabled for this project. Allowed datasets: ${allowed}`,
-                  },
-                ],
-                details: {
-                  error: "dataset_not_allowed",
-                  dataset,
-                  allowed_datasets: allowedIds,
-                },
-              };
-            }
-          }
-
-          const response = await effectiveProvider.searchOpenData(query, {
-            dataset,
-            max_results: maxResults ?? effectiveCfg.topK,
-            start_date: startDate,
-            end_date: endDate,
-          });
-
-          if (!response.results || response.results.length === 0) {
-            return {
-              content: [
-                { type: "text", text: "No relevant open data results found." },
-              ],
-              details: { count: 0, total_results: response.total_results },
-            };
-          }
-
-          const context = buildOpenDataContext(response.results);
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Found ${response.results.length} open data results:\n\n${context}`,
-              },
-            ],
-            details: {
-              count: response.results.length,
-              total_results: response.total_results,
-              results: response.results,
-            },
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Open data search failed: ${String(err)}`,
-              },
-            ],
-            details: { error: String(err) },
-          };
-        }
-      },
-    }),
-  );
-}