@hyperspell/openclaw-hyperspell 0.8.1 → 0.10.0

package/tools/remember.ts

@@ -1,60 +1,68 @@
 import { Type } from "@sinclair/typebox"
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
 import type { HyperspellClient } from "../client.ts"
 import type { HyperspellConfig } from "../config.ts"
+import { resolveUser } from "../lib/sender.ts"
 import { log } from "../logger.ts"
 
-export function registerRememberTool(
-  api: OpenClawPluginApi,
+export function createRememberToolFactory(
   client: HyperspellClient,
-  _cfg: HyperspellConfig,
-): void {
-  api.registerTool(
-    {
-      name: "hyperspell_remember",
-      label: "Memory Store",
-      description: "Save important information to the user's memory.",
-      parameters: Type.Object({
-        text: Type.String({ description: "Information to remember" }),
-        title: Type.Optional(
-          Type.String({ description: "Optional title for the memory" }),
-        ),
-        date: Type.Optional(
-          Type.String({ description: "Date of the memory (ISO 8601 or YYYY-MM-DD). Helps ranking and enables date-range filtering. Defaults to now if omitted." }),
-        ),
-      }),
-      async execute(
-        _toolCallId: string,
-        params: { text: string; title?: string; date?: string },
-      ) {
-        log.debug(`remember tool: "${params.text.slice(0, 50)}..." date=${params.date ?? "now"}`)
+  cfg: HyperspellConfig,
+) {
+  return (ctx: Record<string, unknown>) => ({
+    name: "hyperspell_remember",
+    label: "Memory Store",
+    description: "Save important information to the user's memory.",
+    parameters: Type.Object({
+      text: Type.String({ description: "Information to remember" }),
+      title: Type.Optional(
+        Type.String({ description: "Optional title for the memory" }),
+      ),
+      date: Type.Optional(
+        Type.String({ description: "Date of the memory (ISO 8601 or YYYY-MM-DD). Helps ranking and enables date-range filtering. Defaults to now if omitted." }),
+      ),
+      userId: Type.Optional(
+        Type.String({
+          description:
+            "Store for a specific user or 'shared' for everyone. Omit to store for current sender.",
+        }),
+      ),
+    }),
+    async execute(
+      _toolCallId: string,
+      params: { text: string; title?: string; date?: string; userId?: string },
+    ) {
+      // Resolve userId: explicit param > sender resolution > config default
+      const resolved = resolveUser(ctx, cfg)
+      const userId = params.userId ?? resolved?.userId
+      log.debug(
+        `remember tool: "${params.text.slice(0, 50)}..." date=${params.date ?? "now"} userId=${userId}`,
+      )
 
-        try {
-          await client.addMemory(params.text, {
-            title: params.title,
-            date: params.date,
-            metadata: { source: "openclaw_tool" },
-          })
+      try {
+        await client.addMemory(params.text, {
+          title: params.title,
+          date: params.date,
+          metadata: { source: "openclaw_tool" },
+          userId,
+        })
 
-          const preview =
-            params.text.length > 80 ? `${params.text.slice(0, 80)}…` : params.text
+        const preview =
+          params.text.length > 80 ? `${params.text.slice(0, 80)}…` : params.text
 
-          return {
-            content: [{ type: "text" as const, text: `Stored: "${preview}"` }],
-          }
-        } catch (err) {
-          log.error("remember tool failed", err)
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Failed to store memory: ${err instanceof Error ? err.message : String(err)}`,
-              },
-            ],
-          }
+        return {
+          content: [{ type: "text" as const, text: `Stored: "${preview}"` }],
         }
-      },
+      } catch (err) {
+        log.error("remember tool failed", err)
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to store memory: ${err instanceof Error ? err.message : String(err)}`,
+            },
+          ],
+        }
+      }
     },
-    { name: "hyperspell_remember" },
-  )
+  })
 }

package/tools/search.ts

@@ -1,98 +1,102 @@
 import { Type } from "@sinclair/typebox"
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
 import type { HyperspellClient } from "../client.ts"
 import type { HyperspellConfig } from "../config.ts"
+import { resolveUser } from "../lib/sender.ts"
 import { log } from "../logger.ts"
 
-export function registerSearchTool(
-  api: OpenClawPluginApi,
+export function createSearchToolFactory(
   client: HyperspellClient,
-  _cfg: HyperspellConfig,
-): void {
-  api.registerTool(
-    {
-      name: "hyperspell_search",
-      label: "Memory Search",
-      description:
-        "Search through the user's connected sources (Notion, Slack, Gmail, Google Drive, etc.) for relevant information.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query" }),
-        limit: Type.Optional(
-          Type.Number({ description: "Max results (default: 5)" }),
-        ),
-        after: Type.Optional(
-          Type.String({ description: "Only return memories created on or after this date (ISO 8601 or YYYY-MM-DD)" }),
-        ),
-        before: Type.Optional(
-          Type.String({ description: "Only return memories created before this date (ISO 8601 or YYYY-MM-DD)" }),
-        ),
-      }),
-      async execute(
-        _toolCallId: string,
-        params: { query: string; limit?: number; after?: string; before?: string },
-      ) {
-        const limit = params.limit ?? 5
-        log.debug(`search tool: query="${params.query}" limit=${limit} after=${params.after ?? "none"} before=${params.before ?? "none"}`)
+  cfg: HyperspellConfig,
+) {
+  return (ctx: Record<string, unknown>) => ({
+    name: "hyperspell_search",
+    label: "Memory Search",
+    description:
+      "Search through the user's connected sources (Notion, Slack, Gmail, Google Drive, etc.) for relevant information.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query" }),
+      limit: Type.Optional(
+        Type.Number({ description: "Max results (default: 5)" }),
+      ),
+      after: Type.Optional(
+        Type.String({ description: "Only return memories created on or after this date (ISO 8601 or YYYY-MM-DD)" }),
+      ),
+      before: Type.Optional(
+        Type.String({ description: "Only return memories created before this date (ISO 8601 or YYYY-MM-DD)" }),
+      ),
+      userId: Type.Optional(
+        Type.String({
+          description:
+            "Search as a specific user (e.g. 'ben', 'shared'). Omit to search as current sender.",
+        }),
+      ),
+    }),
+    async execute(
+      _toolCallId: string,
+      params: { query: string; limit?: number; after?: string; before?: string; userId?: string },
+    ) {
+      const limit = params.limit ?? 5
+      // Resolve userId: explicit param > sender resolution > config default
+      const resolved = resolveUser(ctx, cfg)
+      const userId = params.userId ?? resolved?.userId
+      log.debug(
+        `search tool: query="${params.query}" limit=${limit} after=${params.after ?? "none"} before=${params.before ?? "none"} userId=${userId}`,
+      )
 
-        try {
-          const response = await client.searchRaw(params.query, { limit, after: params.after, before: params.before })
-          const documents = (response.documents ?? []) as Array<{
-            source: string
-            resource_id: string
-            score?: number
-            summary?: string
-            title?: string
-            metadata?: Record<string, unknown>
-            highlights?: Array<{ text: string }>
-            data?: Array<{ text: string }>
-          }>
+      try {
+        const response = await client.searchRaw(params.query, {
+          limit,
+          after: params.after,
+          before: params.before,
+          userId,
+        })
+        const documents = (response.documents ?? []) as Array<{
+          source: string
+          resource_id: string
+          score?: number
+          summary?: string
+          title?: string
+          metadata?: Record<string, unknown>
+          highlights?: Array<{ text: string }>
+          data?: Array<{ text: string }>
+        }>
 
-          if (documents.length === 0) {
-            return {
-              content: [
-                { type: "text" as const, text: "No relevant memories found." },
-              ],
-            }
+        if (documents.length === 0) {
+          return {
+            content: [
+              { type: "text" as const, text: "No relevant memories found." },
+            ],
           }
+        }
 
-          const formattedDocs = documents
-            .map((doc, i) => {
-              const relevance = doc.score
-                ? `${Math.round(doc.score * 100)}%`
-                : "N/A"
-              const title = doc.title || "(untitled)"
-              const summary = doc.summary || "(no summary)"
-              return `${i + 1}. Source: ${doc.source}\n   Title: ${title}\n   Summary: ${summary}\n   Relevance: ${relevance}`
-            })
-            .join("\n\n")
+        const formattedDocs = documents
+          .map((doc, i) => {
+            const relevance = doc.score
+              ? `${Math.round(doc.score * 100)}%`
+              : "N/A"
+            const title = doc.title || "(untitled)"
+            const summary = doc.summary || "(no summary)"
+            return `${i + 1}. Source: ${doc.source}\n   Title: ${title}\n   Summary: ${summary}\n   Relevance: ${relevance}`
+          })
+          .join("\n\n")
 
-          const text = `Found ${documents.length} memories:\n\n${formattedDocs}`
+        const text = `Found ${documents.length} memories:\n\n${formattedDocs}`
 
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text,
-              },
-            ],
-            details: {
-              count: documents.length,
-              documents,
+        return {
+          content: [{ type: "text" as const, text }],
+          details: { count: documents.length, documents },
+        }
+      } catch (err) {
+        log.error("search tool failed", err)
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
             },
-          }
-        } catch (err) {
-          log.error("search tool failed", err)
-          return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
-              },
-            ],
-          }
+          ],
         }
-      },
+      }
     },
-    { name: "hyperspell_search" },
-  )
+  })
 }

package/types/openclaw.d.ts

@@ -48,6 +48,22 @@ declare module "openclaw/plugin-sdk" {
       },
       meta: { name: string },
     ): void
+    registerTool<T = unknown>(
+      factory: (ctx: Record<string, unknown>) => {
+        name: string
+        label: string
+        description: string
+        parameters: unknown
+        execute: (
+          toolCallId: string,
+          params: T,
+        ) => Promise<{
+          content: Array<{ type: "text"; text: string }>
+          details?: Record<string, unknown>
+        }>
+      },
+      meta: { name: string },
+    ): void
     on(event: string, handler: (event: Record<string, unknown>, ctx?: Record<string, unknown>) => Promise<{ prependContext?: string } | void> | void): void
     registerService(options: {
       id: string