@lanonasis/mem-intel-sdk 2.0.1 → 2.0.3

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.0.3] - 2026-02-25
+
+### Added
+
+- **Behavior methods changelog/documentation parity**:
+  - `recordBehavior()` - persist successful workflow patterns
+  - `recallBehavior()` - retrieve similar patterns by contextual similarity
+  - `suggestAction()` - generate next-step suggestions from learned workflows
+  - `listBehaviorPatterns()` - enumerate saved behavior patterns for a user
+- Added concrete SDK README usage examples for the behavior method surface above (request shape + expected usage flow).
+
+### Fixed
+
+- **Declaration build completeness**: fixed SDK declaration generation so publish artifacts include all expected `.d.ts` entrypoints for `.` / `core` / `node` / `react` / `vue` / `server`.
+- Reduced declaration build pressure by preventing oversized MCP server type inference during declaration emit and disabling declaration/source maps for the declaration-only build step.
+
 ## [2.0.0] - 2026-01-13
 
 ### The AI That Anticipates What You Need

package/README.md

@@ -39,6 +39,7 @@ const predictions = await client.predictiveRecall({
 - **Pattern Recognition** - Understand usage trends and productivity patterns
 - **Smart Organization** - AI-powered tag suggestions and duplicate detection
 - **Semantic Intelligence** - Find related memories using vector similarity
+- **Behavioral Learning** - Record, recall, and suggest next actions from successful workflows
 - **Actionable Insights** - Extract key learnings and opportunities from your knowledge base
 - **Health Monitoring** - Ensure your memory database stays organized and healthy
 
@@ -155,6 +156,76 @@ onMounted(() => {
 </script>
 ```
 
+## Behavior Learning APIs
+
+Use behavior methods when you want the SDK to learn from successful execution patterns and suggest next actions on future tasks.
+
+### 1) Record a successful workflow
+
+```typescript
+const record = await client.recordBehavior({
+  user_id: "user-123",
+  trigger: "Need to migrate endpoint auth middleware to bearer-first flow",
+  context: {
+    project: "lanonasis-cli",
+    current_task: "auth transport migration",
+  },
+  actions: [
+    { tool: "read_file", params: { path: "src/utils/api.ts" } },
+    { tool: "edit_file", params: { path: "src/utils/api.ts" } },
+    { tool: "run_tests", params: { target: "api-client-auth-header.test.ts" } },
+  ],
+  final_outcome: "Bearer flow migration completed and tests passed",
+  confidence: 0.82,
+});
+
+console.log(record.data.was_duplicate, record.data.pattern.id);
+```
+
+### 2) Recall similar behavior for a new task
+
+```typescript
+const recall = await client.recallBehavior({
+  user_id: "user-123",
+  context: {
+    current_task: "Add token refresh to memory command execution path",
+  },
+  limit: 5,
+  similarity_threshold: 0.7,
+});
+
+for (const match of recall.data.patterns) {
+  console.log(match.similarity_score, match.pattern.trigger);
+}
+```
+
+### 3) Suggest next actions from learned patterns
+
+```typescript
+const suggestion = await client.suggestAction({
+  user_id: "user-123",
+  current_state: {
+    task_description: "Finalize CLI release notes and dry-run publish",
+    completed_steps: [
+      { tool: "update_changelog" },
+      { tool: "bump_version" },
+    ],
+  },
+  max_suggestions: 3,
+});
+
+console.log(suggestion.data.suggestions);
+```
+
+### 4) List existing behavior patterns
+
+```typescript
+const patterns = await client.listBehaviorPatterns("user-123", {
+  limit: 20,
+  offset: 0,
+});
+```
+
 ## Predictive Memory System (v2.0.0)
 
 The flagship feature that makes your memory system feel magical.
@@ -336,9 +407,9 @@ Create a `.env` file with your existing LanOnasis credentials:
 
 ```env
 # Required - Same as your @lanonasis/mcp-core
-ONASIS_SUPABASE_URL=your_supabase_url
-ONASIS_SUPABASE_SERVICE_KEY=your_service_key
-OPENAI_API_KEY=your_openai_key
+ONASIS_SUPABASE_URL=https://<project-ref>.supabase.co
+REDACTED_SUPABASE_SERVICE_ROLE_KEY=REDACTED_SUPABASE_SERVICE_ROLE_KEY
+OPENAI_API_KEY=REDACTED_OPENAI_API_KEY
 
 # Optional
 TRANSPORT=stdio  # or 'http' for HTTP mode
@@ -585,18 +656,18 @@ Add to your `claude_desktop_config.json`:
       "command": "node",
       "args": ["/path/to/mcp-core/dist/index.js"],
       "env": {
-        "ONASIS_SUPABASE_URL": "...",
-        "ONASIS_SUPABASE_SERVICE_KEY": "...",
-        "OPENAI_API_KEY": "..."
+        "ONASIS_SUPABASE_URL=https://<project-ref>.supabase.co
+        "ONASIS_SUPABASE_SERVICE_KEY=REDACTED_SUPABASE_SERVICE_ROLE_KEY
+        "OPENAI_API_KEY=REDACTED_OPENAI_API_KEY
       }
     },
     "memory-intelligence": {
       "command": "node",
       "args": ["/path/to/memory-intelligence-mcp-server/dist/index.js"],
       "env": {
-        "ONASIS_SUPABASE_URL": "...",
-        "ONASIS_SUPABASE_SERVICE_KEY": "...",
-        "OPENAI_API_KEY": "..."
+        "ONASIS_SUPABASE_URL=https://<project-ref>.supabase.co
+        "ONASIS_SUPABASE_SERVICE_KEY=REDACTED_SUPABASE_SERVICE_ROLE_KEY
+        "OPENAI_API_KEY=REDACTED_OPENAI_API_KEY
       }
     }
   }
@@ -637,7 +708,7 @@ Tools return actionable error messages:
   "content": [
     {
       "type": "text",
-      "text": "Error analyzing patterns: Database connection failed. Try checking your ONASIS_SUPABASE_URL environment variable."
+      "text": "Error analyzing patterns: Database connection failed. Try checking your ONASIS_SUPABASE_URL=https://<project-ref>.supabase.co
     }
   ]
 }

package/dist/core/behavior-types.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Behavioral Pattern Learning Types
+ *
+ * These types support the AI-powered behavioral learning system that:
+ * - Records successful workflows and action patterns
+ * - Recalls similar patterns based on current context
+ * - Suggests next actions based on learned behaviors
+ *
+ * The system stores trigger embeddings for semantic similarity search,
+ * enabling the SDK to anticipate what actions users might want to take.
+ */
+import { z } from "zod";
+/**
+ * A single action within a behavior pattern
+ */
+export interface BehaviorAction {
+    /** Tool or action identifier */
+    tool: string;
+    /** Parameters used with this action */
+    params?: Record<string, unknown>;
+    /** Timestamp when action occurred */
+    timestamp?: string;
+    /** Duration in milliseconds (if applicable) */
+    duration_ms?: number;
+}
+/**
+ * Context that was active when a behavior pattern was recorded
+ */
+export interface BehaviorContext {
+    /** Current project or workspace */
+    project?: string;
+    /** Files that were open/active */
+    active_files?: string[];
+    /** Current task or goal description */
+    current_task?: string;
+    /** Environment metadata (IDE, terminal, etc.) */
+    environment?: string;
+    /** Additional custom context */
+    [key: string]: unknown;
+}
+/**
+ * A recorded behavior pattern with embeddings for similarity search
+ */
+export interface BehaviorPattern {
+    /** Unique identifier */
+    id: string;
+    /** User who created this pattern */
+    user_id: string;
+    /** Natural language description of what triggered this pattern */
+    trigger: string;
+    /** Vector embedding of the trigger for semantic search (1536 dimensions for text-embedding-3-small) */
+    trigger_embedding?: number[];
+    /** Context when pattern was recorded */
+    context: BehaviorContext;
+    /** Ordered list of actions taken */
+    actions: BehaviorAction[];
+    /** Description of the final outcome/result */
+    final_outcome: string;
+    /** Confidence score (0-1) indicating pattern reliability */
+    confidence: number;
+    /** Number of times this pattern has been recalled/used */
+    use_count: number;
+    /** Similarity score (only present in search results) */
+    similarity?: number;
+    /** When the pattern was created */
+    created_at: string;
+    /** When the pattern was last updated/used */
+    updated_at: string;
+}
+/**
+ * Parameters for recording a new behavior pattern
+ */
+export interface RecordBehaviorParams {
+    /** User ID (UUID) */
+    user_id: string;
+    /** Natural language description of what triggered this workflow */
+    trigger: string;
+    /** Context when the pattern occurred */
+    context?: BehaviorContext;
+    /** Ordered list of actions taken */
+    actions: BehaviorAction[];
+    /** Description of the final outcome */
+    final_outcome: string;
+    /** Confidence in this pattern (0-1, default: 0.7) */
+    confidence?: number;
+}
+/** Zod schema for API validation */
+export declare const RecordBehaviorParamsSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    trigger: z.ZodString;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actions: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        timestamp: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        params?: Record<string, unknown> | undefined;
+        timestamp?: string | undefined;
+        duration_ms?: number | undefined;
+    }, {
+        tool: string;
+        params?: Record<string, unknown> | undefined;
+        timestamp?: string | undefined;
+        duration_ms?: number | undefined;
+    }>, "many">;
+    final_outcome: z.ZodString;
+    confidence: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    actions: {
+        tool: string;
+        params?: Record<string, unknown> | undefined;
+        timestamp?: string | undefined;
+        duration_ms?: number | undefined;
+    }[];
+    user_id: string;
+    trigger: string;
+    final_outcome: string;
+    confidence: number;
+    context?: Record<string, unknown> | undefined;
+}, {
+    actions: {
+        tool: string;
+        params?: Record<string, unknown> | undefined;
+        timestamp?: string | undefined;
+        duration_ms?: number | undefined;
+    }[];
+    user_id: string;
+    trigger: string;
+    final_outcome: string;
+    context?: Record<string, unknown> | undefined;
+    confidence?: number | undefined;
+}>;
+/**
+ * Response from recording a behavior pattern
+ */
+export interface RecordBehaviorResult {
+    /** The created or updated pattern */
+    pattern: BehaviorPattern;
+    /** Whether a duplicate was updated instead of creating new */
+    was_duplicate: boolean;
+    /** Message describing what happened */
+    message: string;
+}
+/**
+ * Parameters for recalling similar behavior patterns
+ */
+export interface RecallBehaviorParams {
+    /** User ID (UUID) */
+    user_id: string;
+    /** Current context for similarity matching */
+    context: {
+        /** Current task description (required for embedding generation) */
+        current_task: string;
+        /** Optional additional context fields */
+        [key: string]: unknown;
+    };
+    /** Maximum patterns to return (default: 5) */
+    limit?: number;
+    /** Minimum similarity threshold (0-1, default: 0.7) */
+    similarity_threshold?: number;
+}
+/** Zod schema for API validation */
+export declare const RecallBehaviorParamsSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    context: z.ZodObject<{
+        current_task: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        current_task: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        current_task: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    similarity_threshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    context: {
+        current_task: string;
+    } & {
+        [k: string]: unknown;
+    };
+    limit: number;
+    user_id: string;
+    similarity_threshold: number;
+}, {
+    context: {
+        current_task: string;
+    } & {
+        [k: string]: unknown;
+    };
+    user_id: string;
+    limit?: number | undefined;
+    similarity_threshold?: number | undefined;
+}>;
+/**
+ * A recalled pattern with similarity information
+ */
+export interface RecalledPattern {
+    /** The matched pattern */
+    pattern: BehaviorPattern;
+    /** Similarity score (0-1) */
+    similarity_score: number;
+    /** Human-readable explanation of why this matched */
+    relevance_reason: string;
+}
+/**
+ * Response from recalling behavior patterns
+ */
+export interface RecallBehaviorResult {
+    /** Matched patterns sorted by similarity */
+    patterns: RecalledPattern[];
+    /** Total patterns found */
+    total_found: number;
+}
+/**
+ * Parameters for getting action suggestions
+ */
+export interface SuggestActionParams {
+    /** User ID (UUID) */
+    user_id: string;
+    /** Current state for action prediction */
+    current_state: {
+        /** Description of current task */
+        task_description: string;
+        /** Steps already completed (for predicting next step) */
+        completed_steps?: BehaviorAction[];
+        /** Optional additional state */
+        [key: string]: unknown;
+    };
+    /** Maximum suggestions to return (default: 3) */
+    max_suggestions?: number;
+}
+/** Zod schema for API validation */
+export declare const SuggestActionParamsSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    current_state: z.ZodObject<{
+        task_description: z.ZodString;
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        task_description: z.ZodString;
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        task_description: z.ZodString;
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }, {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    max_suggestions: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    user_id: string;
+    current_state: {
+        task_description: string;
+        completed_steps?: {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    max_suggestions: number;
+}, {
+    user_id: string;
+    current_state: {
+        task_description: string;
+        completed_steps?: {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    max_suggestions?: number | undefined;
+}>;
+/**
+ * A suggested next action based on learned patterns
+ */
+export interface ActionSuggestion {
+    /** Suggested action description */
+    action: string;
+    /** Tool to use for this action */
+    tool: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Pattern IDs that informed this suggestion */
+    based_on_patterns: string[];
+    /** Human-readable explanation */
+    reasoning: string;
+}
+/**
+ * Response from action suggestion endpoint
+ */
+export interface SuggestActionResult {
+    /** Suggested actions sorted by confidence */
+    suggestions: ActionSuggestion[];
+}
+/**
+ * Standard response format from behavior edge functions
+ */
+export interface BehaviorEdgeFunctionResponse<T> {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Response data (present on success) */
+    data?: T;
+    /** Error information (present on failure) */
+    error?: {
+        message: string;
+        code: string;
+    };
+    /** Optional message (for duplicate detection, etc.) */
+    message?: string;
+}

package/dist/core/client.d.ts

@@ -4,6 +4,7 @@
  */
 import { MemoryIntelligenceConfig, AnalyzePatternsParams, PatternAnalysis, SuggestTagsParams, TagSuggestionsResult, FindRelatedParams, RelatedMemoriesResult, DetectDuplicatesParams, DuplicatesResult, ExtractInsightsParams, InsightsResult, HealthCheckParams, MemoryHealth, QueryMemoriesOptions, MemoryEntry, ProcessingMode } from "./types.js";
 import { PredictiveRecallParams, PredictiveRecallResult } from "./prediction-types.js";
+import { RecordBehaviorParams, RecordBehaviorResult, RecallBehaviorParams, RecallBehaviorResult, SuggestActionParams, SuggestActionResult, BehaviorPattern } from "./behavior-types.js";
 import { HttpClient } from "../utils/http-client.js";
 import { UsageInfo, TierInfo } from "../utils/response-adapter.js";
 export interface IntelligenceResponse<T> {
@@ -111,5 +112,100 @@ export declare class MemoryIntelligenceClient {
         action: "clicked" | "saved" | "dismissed" | "ignored";
         dismissReason?: "not_relevant" | "already_know" | "not_now" | "other";
     }): Promise<void>;
+    /**
+     * Record a successful behavior pattern for future recall
+     *
+     * The system automatically:
+     * - Generates an embedding from the trigger description
+     * - Detects and updates duplicates (>95% similarity)
+     * - Tracks usage counts for pattern prioritization
+     *
+     * @example
+     * ```typescript
+     * const result = await client.recordBehavior({
+     *   user_id: "user-123",
+     *   trigger: "User wants to refactor a React component to use hooks",
+     *   context: {
+     *     project: "dashboard-app",
+     *     active_files: ["src/components/DataTable.tsx"]
+     *   },
+     *   actions: [
+     *     { tool: "read_file", params: { path: "src/components/DataTable.tsx" } },
+     *     { tool: "analyze_code", params: { focus: "class_components" } },
+     *     { tool: "edit_file", params: { path: "src/components/DataTable.tsx" } }
+     *   ],
+     *   final_outcome: "Successfully converted class component to functional with hooks"
+     * });
+     *
+     * if (result.data.was_duplicate) {
+     *   console.log("Updated existing pattern:", result.data.pattern.id);
+     * }
+     * ```
+     */
+    recordBehavior(params: RecordBehaviorParams): Promise<IntelligenceResponse<RecordBehaviorResult>>;
+    /**
+     * Recall similar behavior patterns based on current context
+     *
+     * Use this to find workflows that match the user's current task,
+     * enabling AI assistants to suggest proven approaches.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.recallBehavior({
+     *   user_id: "user-123",
+     *   context: {
+     *     current_task: "Need to optimize database queries for user dashboard"
+     *   },
+     *   limit: 5,
+     *   similarity_threshold: 0.7
+     * });
+     *
+     * for (const match of result.data.patterns) {
+     *   console.log(`[${Math.round(match.similarity_score * 100)}%] ${match.pattern.trigger}`);
+     *   console.log(`  Actions: ${match.pattern.actions.map(a => a.tool).join(" → ")}`);
+     * }
+     * ```
+     */
+    recallBehavior(params: RecallBehaviorParams): Promise<IntelligenceResponse<RecallBehaviorResult>>;
+    /**
+     * Get AI-powered action suggestions based on learned patterns
+     *
+     * Analyzes the current state and completed steps to predict
+     * what action the user should take next based on similar workflows.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.suggestAction({
+     *   user_id: "user-123",
+     *   current_state: {
+     *     task_description: "Implementing user authentication with OAuth",
+     *     completed_steps: [
+     *       { tool: "create_file", params: { path: "src/auth/oauth.ts" } },
+     *       { tool: "read_file", params: { path: "package.json" } }
+     *     ]
+     *   },
+     *   max_suggestions: 3
+     * });
+     *
+     * for (const suggestion of result.data.suggestions) {
+     *   console.log(`[${Math.round(suggestion.confidence * 100)}%] ${suggestion.action}`);
+     *   console.log(`  Tool: ${suggestion.tool}`);
+     *   console.log(`  Why: ${suggestion.reasoning}`);
+     * }
+     * ```
+     */
+    suggestAction(params: SuggestActionParams): Promise<IntelligenceResponse<SuggestActionResult>>;
+    /**
+     * List all behavior patterns for a user
+     *
+     * @example
+     * ```typescript
+     * const patterns = await client.listBehaviorPatterns("user-123", { limit: 20 });
+     * console.log(`Found ${patterns.length} patterns`);
+     * ```
+     */
+    listBehaviorPatterns(userId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<BehaviorPattern[]>;
 }
-//# sourceMappingURL=client.d.ts.map

package/dist/core/errors.d.ts

@@ -21,4 +21,3 @@ export declare class EmbeddingError extends MemoryIntelligenceError {
 export declare class ValidationError extends MemoryIntelligenceError {
     constructor(message: string);
 }
-//# sourceMappingURL=errors.d.ts.map