@minns/openclaw-minns 0.6.5 → 0.6.6

package/dist/index.js

@@ -55,7 +55,7 @@ export default {
                     return { text: "pong" };
                 if (arg === "health") {
                     try {
-                        const result = await dispatch(minnsClient, "health.check", {});
+                        const result = await dispatch(minnsClient, "health_check", {});
                         return { text: JSON.stringify(result, null, 2) };
                     }
                     catch (err) {
@@ -114,7 +114,7 @@ export default {
                 const parts = [];
                 const queryId = `recall_${Date.now()}`;
                 try {
-                    const memories = await dispatch(minnsClient, "memory.search", {
+                    const memories = await dispatch(minnsClient, "memory_search", {
                         query: prompt,
                         limit: cfg.topK,
                         agent_id: OBS_AGENT_ID,
@@ -378,7 +378,7 @@ export default {
                 .option("--limit <n>", "Max results", String(cfg.topK))
                 .action(async (query, opts) => {
                 try {
-                    const result = await dispatch(minnsClient, "memory.search", {
+                    const result = await dispatch(minnsClient, "memory_search", {
                         query,
                         limit: parseInt(opts.limit, 10),
                         agent_id: OBS_AGENT_ID,
@@ -394,7 +394,7 @@ export default {
                 .description("Show system statistics")
                 .action(async () => {
                 try {
-                    const result = await dispatch(minnsClient, "stats.get", {});
+                    const result = await dispatch(minnsClient, "stats_get", {});
                     console.log(JSON.stringify(result, null, 2));
                 }
                 catch (err) {
@@ -406,7 +406,7 @@ export default {
                 .description("Check EventGraphDB health")
                 .action(async () => {
                 try {
-                    const result = await dispatch(minnsClient, "health.check", {});
+                    const result = await dispatch(minnsClient, "health_check", {});
                     console.log(JSON.stringify(result, null, 2));
                 }
                 catch (err) {

package/dist/tools.js

@@ -156,57 +156,57 @@ function zodFieldToJson(field) {
 // ---------------------------------------------------------------------------
 export const TOOL_DEFS = [
     {
-        name: "memory.search",
+        name: "memory_search",
         description: "Search memories by semantic similarity to a query string. Returns the most relevant memories.",
         inputSchema: zodToJsonSchema(MemorySearchSchema),
     },
     {
-        name: "memory.capture",
+        name: "memory_capture",
         description: "Capture a new memory via the fluent event builder. Sends a Context event with semantic indexing enabled. Optionally attach goals.",
         inputSchema: zodToJsonSchema(MemoryCaptureSchema),
     },
     {
-        name: "memory.memories",
+        name: "memory_memories",
         description: "List memories for a specific agent, sorted by strength.",
         inputSchema: zodToJsonSchema(MemoryMemoriesSchema),
     },
     {
-        name: "memory.strategies",
+        name: "memory_strategies",
         description: "List strategies learned by a specific agent, sorted by quality score.",
         inputSchema: zodToJsonSchema(MemoryStrategiesSchema),
     },
     {
-        name: "strategy.similar",
+        name: "strategy_similar",
         description: "Find strategies similar to a given signature (goals, tools, results, context).",
         inputSchema: zodToJsonSchema(StrategySimilarSchema),
     },
     {
-        name: "strategy.suggest_next_action",
+        name: "strategy_suggest_next_action",
         description: "Get action suggestions for a context hash based on learned strategies.",
         inputSchema: zodToJsonSchema(StrategySuggestSchema),
     },
     {
-        name: "claims.search",
+        name: "claims_search",
         description: "Search claims extracted from events via semantic similarity.",
         inputSchema: zodToJsonSchema(ClaimsSearchSchema),
     },
     {
-        name: "stats.get",
+        name: "stats_get",
         description: "Get system-wide statistics about EventGraphDB.",
         inputSchema: zodToJsonSchema(StatsGetSchema),
     },
     {
-        name: "health.check",
+        name: "health_check",
         description: "Health check -- verify that EventGraphDB is running.",
         inputSchema: zodToJsonSchema(HealthCheckSchema),
     },
     {
-        name: "intent.instruction",
+        name: "intent_instruction",
         description: "Get the sidecar instruction prompt for a given agent type. Inject this into your system prompt so the LLM outputs structured intent JSON alongside its response.",
         inputSchema: zodToJsonSchema(IntentInstructionSchema),
     },
     {
-        name: "intent.parse",
+        name: "intent_parse",
         description: "Parse raw LLM output into a structured intent + assistant response using the sidecar extractor. Returns the parsed intent (with slots, goal_updates, claims_hint) and the clean assistant text.",
         inputSchema: zodToJsonSchema(IntentParseSchema),
     },
@@ -223,7 +223,7 @@ function resolveSpec(agentType, goals) {
 export async function dispatch(client, toolName, rawArgs) {
     switch (toolName) {
         // ---- Memory tools ---------------------------------------------------
-        case "memory.search": {
+        case "memory_search": {
             const args = MemorySearchSchema.parse(rawArgs);
             // Use the fluent builder to construct a minimal search context,
             // then extract the built EventContext for the query API.
@@ -242,7 +242,7 @@ export async function dispatch(client, toolName, rawArgs) {
                 session_id: args.session_id,
             });
         }
-        case "memory.capture": {
+        case "memory_capture": {
             const args = MemoryCaptureSchema.parse(rawArgs);
             const builder = client
                 .event(args.agent_type, {
@@ -261,16 +261,16 @@ export async function dispatch(client, toolName, rawArgs) {
             }
             return builder.send();
         }
-        case "memory.memories": {
+        case "memory_memories": {
             const args = MemoryMemoriesSchema.parse(rawArgs);
             return client.getAgentMemories(args.agent_id, args.limit);
         }
-        case "memory.strategies": {
+        case "memory_strategies": {
             const args = MemoryStrategiesSchema.parse(rawArgs);
             return client.getAgentStrategies(args.agent_id, args.limit);
         }
         // ---- Strategy tools -------------------------------------------------
-        case "strategy.similar": {
+        case "strategy_similar": {
             const args = StrategySimilarSchema.parse(rawArgs);
             return client.getSimilarStrategies({
                 agent_id: args.agent_id,
@@ -282,12 +282,12 @@ export async function dispatch(client, toolName, rawArgs) {
                 limit: args.limit,
             });
         }
-        case "strategy.suggest_next_action": {
+        case "strategy_suggest_next_action": {
             const args = StrategySuggestSchema.parse(rawArgs);
             return client.getActionSuggestions(args.context_hash, args.last_action_node, args.limit);
         }
         // ---- Claims ---------------------------------------------------------
-        case "claims.search": {
+        case "claims_search": {
             const args = ClaimsSearchSchema.parse(rawArgs);
             return client.searchClaims({
                 query_text: args.query_text,
@@ -296,16 +296,16 @@ export async function dispatch(client, toolName, rawArgs) {
             });
         }
         // ---- System ---------------------------------------------------------
-        case "stats.get": {
+        case "stats_get": {
             StatsGetSchema.parse(rawArgs);
             return client.getStats();
         }
-        case "health.check": {
+        case "health_check": {
             HealthCheckSchema.parse(rawArgs);
             return client.healthCheck();
         }
         // ---- Intent sidecar tools -------------------------------------------
-        case "intent.instruction": {
+        case "intent_instruction": {
             const args = IntentInstructionSchema.parse(rawArgs);
             const spec = resolveSpec(args.agent_type, args.goals);
             return {
@@ -314,7 +314,7 @@ export async function dispatch(client, toolName, rawArgs) {
                 intents: spec.intents.map((i) => i.name),
             };
         }
-        case "intent.parse": {
+        case "intent_parse": {
             const args = IntentParseSchema.parse(rawArgs);
             const spec = resolveSpec(args.agent_type, args.goals);
             const { intent, assistantResponse } = extractIntentAndResponse(args.model_text, args.user_message, spec);

package/openclaw.plugin.json

@@ -16,9 +16,6 @@
       "topK": { "type": "number", "default": 5 }
     }
   },
-  "slots": {
-    "memory": "openclaw-minns"
-  },
   "uiHints": {
     "env.MINNS_BASE_URL": { "label": "Minns Base URL" },
     "env.MINNS_API_KEY": { "label": "Minns API Key", "sensitive": true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minns/openclaw-minns",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "MCP stdio server integrating Minns EventGraphDB into OpenClaw",
   "type": "module",
   "main": "./dist/mcp.js",