@lanonasis/mem-intel-sdk 2.0.3 → 2.0.5

package/dist/server/index.cjs

@@ -1504,6 +1504,188 @@ ${data.overall_summary}
       }
     }
   );
+  server.registerTool(
+    "behavior_record",
+    {
+      title: "Record Behavior Pattern",
+      description: `Record a successful workflow pattern for future recall.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        trigger: zod.z.string().min(1, "Trigger description is required"),
+        context: zod.z.object({
+          directory: zod.z.string(),
+          project_type: zod.z.string().optional(),
+          branch: zod.z.string().optional(),
+          files_touched: zod.z.array(zod.z.string()).optional()
+        }).optional(),
+        actions: zod.z.array(zod.z.object({
+          tool: zod.z.string(),
+          parameters: zod.z.record(zod.z.unknown()).optional(),
+          outcome: zod.z.enum(["success", "partial", "failed"]),
+          timestamp: zod.z.string().optional(),
+          duration_ms: zod.z.number().optional()
+        })).min(1, "At least one action is required"),
+        final_outcome: zod.z.enum(["success", "partial", "failed"]),
+        confidence: zod.z.number().min(0).max(1).default(0.7)
+      }).strict(),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.recordBehavior({
+          user_id: rawParams.user_id,
+          trigger: rawParams.trigger,
+          context: rawParams.context || {},
+          actions: rawParams.actions,
+          final_outcome: rawParams.final_outcome,
+          confidence: rawParams.confidence
+        });
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior pattern recorded: ${response.data.message}
+Pattern ID: ${response.data.pattern.id}
+Was duplicate: ${response.data.was_duplicate}`
+          }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "behavior_recall",
+    {
+      title: "Recall Behavior Patterns",
+      description: `Recall similar behavior patterns based on current context.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        context: zod.z.object({
+          current_task: zod.z.string().min(1, "Current task description is required"),
+          directory: zod.z.string().optional(),
+          project_type: zod.z.string().optional()
+        }),
+        limit: zod.z.number().int().min(1).max(20).default(5),
+        similarity_threshold: zod.z.number().min(0).max(1).default(0.7)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.recallBehavior({
+          user_id: rawParams.user_id,
+          context: rawParams.context,
+          limit: rawParams.limit,
+          similarity_threshold: rawParams.similarity_threshold
+        });
+        const patterns = response.data?.patterns || [];
+        let text = `Found ${patterns.length} behavior patterns:
+
+`;
+        patterns.forEach((pattern, i) => {
+          text += `${i + 1}. "${pattern.pattern.trigger}" (${Math.round(pattern.similarity_score * 100)}% similar)
+`;
+          text += `   Actions: ${pattern.pattern.actions.map((a) => a.tool).join(" \u2192 ")}
+`;
+          text += `   Outcome: ${pattern.pattern.final_outcome}
+
+`;
+        });
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "behavior_suggest",
+    {
+      title: "Suggest Next Actions",
+      description: `Get AI-powered action suggestions based on learned patterns.`,
+      inputSchema: zod.z.object({
+        user_id: zod.z.string().uuid(),
+        current_state: zod.z.object({
+          task_description: zod.z.string().min(1, "Task description is required"),
+          completed_steps: zod.z.array(zod.z.object({
+            tool: zod.z.string(),
+            params: zod.z.record(zod.z.unknown()).optional()
+          })).optional()
+        }),
+        max_suggestions: zod.z.number().int().min(1).max(10).default(3)
+      }).strict(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams) => {
+      try {
+        const response = await client.suggestAction({
+          user_id: rawParams.user_id,
+          current_state: rawParams.current_state,
+          max_suggestions: rawParams.max_suggestions
+        });
+        const suggestions = response.data?.suggestions || [];
+        let text = `Suggested actions:
+
+`;
+        suggestions.forEach((suggestion, i) => {
+          text += `${i + 1}. ${suggestion.action}
+`;
+          text += `   Tool: ${suggestion.tool}
+`;
+          text += `   Confidence: ${Math.round(suggestion.confidence * 100)}%
+`;
+          text += `   Reasoning: ${suggestion.reasoning}
+
+`;
+        });
+        return {
+          content: [{ type: "text", text }]
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
   return server;
 }