@lanonasis/mem-intel-sdk 2.0.5 → 2.1.0

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.1.0] - 2026-04-01
+
+### Added
+
+- **Context-aware intelligence query contract**:
+  - added optional `organizationId`, `topicId`, `memoryTypes`, and `queryScope` support to the public SDK query surface
+  - extended predictive recall request typing so the context-aware contract stays consistent across client, MCP server, and internal tools
+- **Shared scoped server-side query resolver**:
+  - internal intelligence tools now resolve personal, organization, and hybrid queries through one shared helper instead of hardcoded `user_id`-only paths
+  - added resolver test coverage for scoped query behavior
+
+### Changed
+
+- **Consumer compatibility alignment**:
+  - CLI intelligence commands now accept additive context flags and forward them through to the SDK contract
+  - dashboard memory-intelligence hook now passes optional context fields through the client layer
+- **Prediction and related-memory internals**:
+  - updated related-memory, health, duplicate, insight, tag, pattern, and predictive helpers to honor the new scoped query contract without forcing a physical storage split
+
+### Fixed
+
+- **Edge envelope compatibility for `queryMemories()`**:
+  - switched the SDK memory query path to the enhanced response adapter so `/intelligence/memories` can use the standard edge-function envelope without breaking the client
+
 ## [2.0.3] - 2026-02-25
 
 ### Added

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

@@ -10,6 +10,8 @@
  * enabling the SDK to anticipate what actions users might want to take.
  */
 import { z } from "zod";
+export declare const BehaviorOutcomeValues: readonly ["success", "partial", "failed"];
+export type BehaviorOutcome = typeof BehaviorOutcomeValues[number];
 /**
  * A single action within a behavior pattern
  */
@@ -17,7 +19,11 @@ export interface BehaviorAction {
     /** Tool or action identifier */
     tool: string;
     /** Parameters used with this action */
+    parameters?: Record<string, unknown>;
+    /** Legacy alias for parameters; use `parameters` for new callers */
     params?: Record<string, unknown>;
+    /** Outcome of the action when recorded as a workflow step */
+    outcome?: BehaviorOutcome;
     /** Timestamp when action occurred */
     timestamp?: string;
     /** Duration in milliseconds (if applicable) */
@@ -48,14 +54,16 @@ export interface BehaviorPattern {
     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) */
+    /** OpenAI-compatible trigger embedding for semantic search */
     trigger_embedding?: number[];
+    /** Voyage trigger embedding for semantic search */
+    voyage_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;
+    /** Final outcome/result classification */
+    final_outcome: BehaviorOutcome;
     /** Confidence score (0-1) indicating pattern reliability */
     confidence: number;
     /** Number of times this pattern has been recalled/used */
@@ -79,8 +87,8 @@ export interface RecordBehaviorParams {
     context?: BehaviorContext;
     /** Ordered list of actions taken */
     actions: BehaviorAction[];
-    /** Description of the final outcome */
-    final_outcome: string;
+    /** Final outcome classification */
+    final_outcome: BehaviorOutcome;
     /** Confidence in this pattern (0-1, default: 0.7) */
     confidence?: number;
 }
@@ -91,44 +99,54 @@ export declare const RecordBehaviorParamsSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     actions: z.ZodArray<z.ZodObject<{
         tool: z.ZodString;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outcome: z.ZodEnum<["success", "partial", "failed"]>;
         timestamp: z.ZodOptional<z.ZodString>;
         duration_ms: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         tool: string;
+        outcome: "success" | "partial" | "failed";
         params?: Record<string, unknown> | undefined;
+        parameters?: Record<string, unknown> | undefined;
         timestamp?: string | undefined;
         duration_ms?: number | undefined;
     }, {
         tool: string;
+        outcome: "success" | "partial" | "failed";
         params?: Record<string, unknown> | undefined;
+        parameters?: Record<string, unknown> | undefined;
         timestamp?: string | undefined;
         duration_ms?: number | undefined;
     }>, "many">;
-    final_outcome: z.ZodString;
+    final_outcome: z.ZodEnum<["success", "partial", "failed"]>;
     confidence: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     actions: {
         tool: string;
+        outcome: "success" | "partial" | "failed";
         params?: Record<string, unknown> | undefined;
+        parameters?: Record<string, unknown> | undefined;
         timestamp?: string | undefined;
         duration_ms?: number | undefined;
     }[];
     user_id: string;
     trigger: string;
-    final_outcome: string;
+    final_outcome: "success" | "partial" | "failed";
     confidence: number;
     context?: Record<string, unknown> | undefined;
 }, {
     actions: {
         tool: string;
+        outcome: "success" | "partial" | "failed";
         params?: Record<string, unknown> | undefined;
+        parameters?: Record<string, unknown> | undefined;
         timestamp?: string | undefined;
         duration_ms?: number | undefined;
     }[];
     user_id: string;
     trigger: string;
-    final_outcome: string;
+    final_outcome: "success" | "partial" | "failed";
     context?: Record<string, unknown> | undefined;
     confidence?: number | undefined;
 }>;
@@ -223,51 +241,71 @@ export interface SuggestActionParams {
         /** Description of current task */
         task_description: string;
         /** Steps already completed (for predicting next step) */
-        completed_steps?: BehaviorAction[];
+        completed_steps?: string[];
         /** 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<{
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
             tool: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, "strip", z.ZodTypeAny, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        }>]>, string, string | {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }>, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         task_description: z.ZodString;
-        completed_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
             tool: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, "strip", z.ZodTypeAny, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        }>]>, string, string | {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }>, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         task_description: z.ZodString;
-        completed_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        completed_steps: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
             tool: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, "strip", z.ZodTypeAny, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }, {
             tool: string;
             params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        }>]>, string, string | {
+            tool: string;
+            params?: Record<string, unknown> | undefined;
+            parameters?: Record<string, unknown> | undefined;
         }>, "many">>;
     }, z.ZodTypeAny, "passthrough">>;
     max_suggestions: z.ZodDefault<z.ZodNumber>;
@@ -275,10 +313,7 @@ export declare const SuggestActionParamsSchema: z.ZodObject<{
     user_id: string;
     current_state: {
         task_description: string;
-        completed_steps?: {
-            tool: string;
-            params?: Record<string, unknown> | undefined;
-        }[] | undefined;
+        completed_steps?: string[] | undefined;
     } & {
         [k: string]: unknown;
     };
@@ -287,10 +322,11 @@ export declare const SuggestActionParamsSchema: z.ZodObject<{
     user_id: string;
     current_state: {
         task_description: string;
-        completed_steps?: {
+        completed_steps?: (string | {
             tool: string;
             params?: Record<string, unknown> | undefined;
-        }[] | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        })[] | undefined;
     } & {
         [k: string]: unknown;
     };

package/dist/core/client.d.ts

@@ -130,11 +130,11 @@ export declare class MemoryIntelligenceClient {
      *     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" } }
+     *     { tool: "read_file", parameters: { path: "src/components/DataTable.tsx" }, outcome: "success" },
+     *     { tool: "analyze_code", parameters: { focus: "class_components" }, outcome: "success" },
+     *     { tool: "edit_file", parameters: { path: "src/components/DataTable.tsx" }, outcome: "success" }
      *   ],
-     *   final_outcome: "Successfully converted class component to functional with hooks"
+     *   final_outcome: "success"
      * });
      *
      * if (result.data.was_duplicate) {
@@ -180,8 +180,8 @@ export declare class MemoryIntelligenceClient {
      *   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" } }
+     *       "create src/auth/oauth.ts",
+     *       "inspect package.json"
      *     ]
      *   },
      *   max_suggestions: 3

package/dist/core/index.cjs

@@ -240,11 +240,12 @@ var HttpClient = class {
       clearTimeout(timeoutId);
       const responseData = await response.json();
       if (!response.ok) {
+        const errorMessage = responseData?.message || responseData?.error?.message || (typeof responseData?.error === "string" ? responseData.error : void 0) || "Request failed";
         return {
           status: response.status,
           error: {
-            message: responseData?.message || responseData?.error || "Request failed",
-            code: responseData?.code
+            message: errorMessage,
+            code: responseData?.code || responseData?.error?.code
           }
         };
       }
@@ -353,6 +354,20 @@ var HttpClient = class {
 
 // src/core/client.ts
 var DEFAULT_API_URL = "https://api.lanonasis.com/api/v1";
+function appendQueryContext(params, context) {
+  if (context.organizationId) {
+    params.append("organization_id", context.organizationId);
+  }
+  if (context.topicId) {
+    params.append("topic_id", context.topicId);
+  }
+  if (context.queryScope) {
+    params.append("query_scope", context.queryScope);
+  }
+  for (const memoryType of context.memoryTypes || []) {
+    params.append("memory_types", memoryType);
+  }
+}
 var MemoryIntelligenceClient = class {
   httpClient;
   defaultResponseFormat;
@@ -402,7 +417,15 @@ var MemoryIntelligenceClient = class {
    * Query memories from the API
    */
   async queryMemories(userId, options = {}) {
-    const { type, limit = 100, offset = 0 } = options;
+    const {
+      type,
+      limit = 100,
+      offset = 0,
+      organizationId,
+      topicId,
+      memoryTypes,
+      queryScope
+    } = options;
     const params = new URLSearchParams({
       user_id: userId,
       limit: limit.toString(),
@@ -411,7 +434,13 @@ var MemoryIntelligenceClient = class {
     if (type) {
       params.append("type", type);
     }
-    const response = await this.httpClient.get(
+    appendQueryContext(params, {
+      organizationId,
+      topicId,
+      memoryTypes,
+      queryScope
+    });
+    const response = await this.httpClient.getEnhanced(
       `/intelligence/memories?${params.toString()}`
     );
     if (response.error) {
@@ -579,6 +608,9 @@ var MemoryIntelligenceClient = class {
       "/intelligence/predictive-recall",
       {
         userId: params.userId,
+        organizationId: params.organizationId,
+        topicId: params.topicId,
+        queryScope: params.queryScope,
         context: params.context,
         limit: params.limit || 5,
         minConfidence: params.minConfidence || 40,
@@ -635,11 +667,11 @@ var MemoryIntelligenceClient = class {
    *     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" } }
+   *     { tool: "read_file", parameters: { path: "src/components/DataTable.tsx" }, outcome: "success" },
+   *     { tool: "analyze_code", parameters: { focus: "class_components" }, outcome: "success" },
+   *     { tool: "edit_file", parameters: { path: "src/components/DataTable.tsx" }, outcome: "success" }
    *   ],
-   *   final_outcome: "Successfully converted class component to functional with hooks"
+   *   final_outcome: "success"
    * });
    *
    * if (result.data.was_duplicate) {
@@ -648,13 +680,20 @@ var MemoryIntelligenceClient = class {
    * ```
    */
   async recordBehavior(params) {
+    const actions = params.actions.map((action) => ({
+      tool: action.tool,
+      ...action.parameters || action.params ? { parameters: action.parameters ?? action.params } : {},
+      ...action.outcome ? { outcome: action.outcome } : {},
+      ...action.timestamp ? { timestamp: action.timestamp } : {},
+      ...action.duration_ms !== void 0 ? { duration_ms: action.duration_ms } : {}
+    }));
     const response = await this.httpClient.postEnhanced(
       "/intelligence/behavior-record",
       {
         user_id: params.user_id,
         trigger: params.trigger,
         context: params.context || {},
-        actions: params.actions,
+        actions,
         final_outcome: params.final_outcome,
         confidence: params.confidence ?? 0.7
       }
@@ -731,8 +770,8 @@ var MemoryIntelligenceClient = class {
    *   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" } }
+   *       "create src/auth/oauth.ts",
+   *       "inspect package.json"
    *     ]
    *   },
    *   max_suggestions: 3
@@ -797,8 +836,17 @@ var MemoryType = zod.z.enum([
   "personal",
   "workflow"
 ]);
+var QueryScope = zod.z.enum([
+  "personal",
+  "team",
+  "organization",
+  "hybrid"
+]);
 var PredictiveRecallParamsSchema = zod.z.object({
   userId: zod.z.string().uuid(),
+  organizationId: zod.z.string().uuid().optional(),
+  topicId: zod.z.string().optional(),
+  queryScope: QueryScope.optional(),
   context: zod.z.object({
     currentProject: zod.z.string().optional(),
     recentTopics: zod.z.array(zod.z.string()).optional(),
@@ -835,17 +883,20 @@ var DEFAULT_SCORING_CONFIG = {
     // Not too different
   }
 };
+var BehaviorOutcomeValues = ["success", "partial", "failed"];
 var RecordBehaviorParamsSchema = zod.z.object({
   user_id: zod.z.string().uuid(),
   trigger: zod.z.string().min(1, "Trigger description is required"),
   context: zod.z.record(zod.z.unknown()).optional(),
   actions: zod.z.array(zod.z.object({
     tool: zod.z.string(),
+    parameters: zod.z.record(zod.z.unknown()).optional(),
     params: zod.z.record(zod.z.unknown()).optional(),
+    outcome: zod.z.enum(BehaviorOutcomeValues),
     timestamp: zod.z.string().optional(),
     duration_ms: zod.z.number().optional()
   })).min(1, "At least one action is required"),
-  final_outcome: zod.z.string().min(1, "Final outcome is required"),
+  final_outcome: zod.z.enum(BehaviorOutcomeValues),
   confidence: zod.z.number().min(0).max(1).default(0.7)
 });
 var RecallBehaviorParamsSchema = zod.z.object({
@@ -856,18 +907,24 @@ var RecallBehaviorParamsSchema = zod.z.object({
   limit: zod.z.number().int().min(1).max(20).default(5),
   similarity_threshold: zod.z.number().min(0).max(1).default(0.7)
 });
+var SuggestActionStepSchema = zod.z.union([
+  zod.z.string().min(1, "Completed step must be a non-empty string"),
+  zod.z.object({
+    tool: zod.z.string().min(1, "Legacy step objects must include tool"),
+    parameters: zod.z.record(zod.z.unknown()).optional(),
+    params: zod.z.record(zod.z.unknown()).optional()
+  })
+]).transform((step) => typeof step === "string" ? step : step.tool);
 var SuggestActionParamsSchema = 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()
+    completed_steps: zod.z.array(SuggestActionStepSchema).optional()
   }).passthrough(),
   max_suggestions: zod.z.number().int().min(1).max(10).default(3)
 });
 
+exports.BehaviorOutcomeValues = BehaviorOutcomeValues;
 exports.ConfigurationError = ConfigurationError;
 exports.DEFAULT_SCORING_CONFIG = DEFAULT_SCORING_CONFIG;
 exports.DatabaseError = DatabaseError;
@@ -877,6 +934,7 @@ exports.MemoryIntelligenceError = MemoryIntelligenceError;
 exports.MemoryNotFoundError = MemoryNotFoundError;
 exports.MemoryType = MemoryType;
 exports.PredictiveRecallParamsSchema = PredictiveRecallParamsSchema;
+exports.QueryScope = QueryScope;
 exports.RecallBehaviorParamsSchema = RecallBehaviorParamsSchema;
 exports.RecordBehaviorParamsSchema = RecordBehaviorParamsSchema;
 exports.ResponseFormat = ResponseFormat;