@lanonasis/mem-intel-sdk 1.0.0 → 1.1.0

package/dist/server/index.js

@@ -43,12 +43,120 @@ var ValidationError = class extends MemoryIntelligenceError {
   }
 };
 
+// src/utils/response-adapter.ts
+function adaptEdgeFunctionResponse(httpResponse) {
+  if (httpResponse.error) {
+    return {
+      status: httpResponse.status,
+      error: httpResponse.error
+    };
+  }
+  const envelope = httpResponse.data;
+  if (!envelope) {
+    return {
+      status: httpResponse.status,
+      error: {
+        message: "Empty response from server",
+        code: "EMPTY_RESPONSE"
+      }
+    };
+  }
+  if (!envelope.success && envelope.error) {
+    return {
+      status: httpResponse.status,
+      error: envelope.error,
+      usage: envelope.usage,
+      tier_info: envelope.tier_info
+    };
+  }
+  return {
+    status: httpResponse.status,
+    data: envelope.data,
+    usage: envelope.usage,
+    tier_info: envelope.tier_info
+  };
+}
+function isEdgeFunctionEnvelope(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const obj = data;
+  return "success" in obj && typeof obj.success === "boolean";
+}
+function adaptResponse(httpResponse) {
+  if (httpResponse.error) {
+    return {
+      status: httpResponse.status,
+      error: httpResponse.error
+    };
+  }
+  const responseData = httpResponse.data;
+  if (isEdgeFunctionEnvelope(responseData)) {
+    return adaptEdgeFunctionResponse({
+      status: httpResponse.status,
+      data: responseData
+    });
+  }
+  return {
+    status: httpResponse.status,
+    data: responseData
+  };
+}
+var ResponseCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttlMs = 3e5) {
+    this.ttl = ttlMs;
+  }
+  generateKey(endpoint, params) {
+    const paramStr = params ? JSON.stringify(params) : "";
+    return `${endpoint}:${paramStr}`;
+  }
+  set(endpoint, data, params) {
+    const key = this.generateKey(endpoint, params);
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      endpoint,
+      params
+    });
+  }
+  get(endpoint, params) {
+    const key = this.generateKey(endpoint, params);
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Clean up expired entries
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.ttl) {
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+
 // src/utils/http-client.ts
 var HttpClient = class {
   apiUrl;
   apiKey;
   timeout;
   headers;
+  processingMode;
+  cache;
   constructor(config) {
     if (!config.apiKey) {
       throw new ConfigurationError("API key is required");
@@ -61,11 +169,35 @@ var HttpClient = class {
     this.apiUrl = config.apiUrl.replace(/\/$/, "");
     this.apiKey = config.apiKey;
     this.timeout = config.timeout || 3e4;
+    this.processingMode = config.processingMode || "api";
     this.headers = {
       "Content-Type": "application/json",
       "X-API-Key": this.apiKey,
       ...config.headers
     };
+    if (config.enableCache !== false && this.processingMode === "offline-fallback") {
+      this.cache = new ResponseCache(config.cacheTTL || 3e5);
+    } else {
+      this.cache = null;
+    }
+  }
+  /**
+   * Get the current processing mode
+   */
+  getProcessingMode() {
+    return this.processingMode;
+  }
+  /**
+   * Check if cache is enabled
+   */
+  isCacheEnabled() {
+    return this.cache !== null;
+  }
+  /**
+   * Clear the response cache
+   */
+  clearCache() {
+    this.cache?.clear();
   }
   async request(method, endpoint, data) {
     const url = `${this.apiUrl}${endpoint}`;
@@ -125,6 +257,43 @@ var HttpClient = class {
       };
     }
   }
+  /**
+   * Enhanced request that handles Edge Function envelope format
+   * and supports offline-fallback caching
+   */
+  async enhancedRequest(method, endpoint, data) {
+    const cacheKey = data ? JSON.stringify(data) : void 0;
+    const rawResponse = await this.request(method, endpoint, data);
+    if (rawResponse.error?.code === "NETWORK_ERROR" || rawResponse.error?.code === "TIMEOUT") {
+      if (this.processingMode === "offline-fallback" && this.cache) {
+        const cached = this.cache.get(endpoint, cacheKey ? JSON.parse(cacheKey) : void 0);
+        if (cached) {
+          return {
+            status: 200,
+            data: cached,
+            fromCache: true
+          };
+        }
+      }
+      return {
+        status: rawResponse.status,
+        error: rawResponse.error,
+        fromCache: false
+      };
+    }
+    const adapted = adaptResponse(rawResponse);
+    if (!adapted.error && adapted.data && this.cache) {
+      this.cache.set(endpoint, adapted.data, cacheKey ? JSON.parse(cacheKey) : void 0);
+    }
+    return {
+      status: adapted.status,
+      data: adapted.data,
+      error: adapted.error,
+      usage: adapted.usage,
+      tier_info: adapted.tier_info,
+      fromCache: false
+    };
+  }
   async get(endpoint) {
     return this.request("GET", endpoint);
   }
@@ -140,6 +309,22 @@ var HttpClient = class {
   async delete(endpoint) {
     return this.request("DELETE", endpoint);
   }
+  // Enhanced methods with Edge Function envelope support
+  async getEnhanced(endpoint) {
+    return this.enhancedRequest("GET", endpoint);
+  }
+  async postEnhanced(endpoint, data) {
+    return this.enhancedRequest("POST", endpoint, data);
+  }
+  async putEnhanced(endpoint, data) {
+    return this.enhancedRequest("PUT", endpoint, data);
+  }
+  async patchEnhanced(endpoint, data) {
+    return this.enhancedRequest("PATCH", endpoint, data);
+  }
+  async deleteEnhanced(endpoint) {
+    return this.enhancedRequest("DELETE", endpoint);
+  }
 };
 
 // src/core/client.ts
@@ -147,20 +332,43 @@ var DEFAULT_API_URL = "https://api.lanonasis.com/api/v1";
 var MemoryIntelligenceClient = class {
   httpClient;
   defaultResponseFormat;
+  processingMode;
   constructor(config) {
     if (!config.apiKey) {
       throw new ConfigurationError(
         "Missing required configuration: apiKey is required (format: lano_xxxxxxxxxx)"
       );
     }
+    this.processingMode = config.processingMode || "api";
     this.httpClient = new HttpClient({
       apiUrl: config.apiUrl || DEFAULT_API_URL,
       apiKey: config.apiKey,
       timeout: config.timeout,
-      headers: config.headers
+      headers: config.headers,
+      processingMode: this.processingMode,
+      enableCache: config.enableCache,
+      cacheTTL: config.cacheTTL
     });
     this.defaultResponseFormat = config.responseFormat || "markdown";
   }
+  /**
+   * Get the current processing mode
+   */
+  getProcessingMode() {
+    return this.processingMode;
+  }
+  /**
+   * Check if cache is enabled (for offline-fallback mode)
+   */
+  isCacheEnabled() {
+    return this.httpClient.isCacheEnabled();
+  }
+  /**
+   * Clear the response cache
+   */
+  clearCache() {
+    this.httpClient.clearCache();
+  }
   /**
    * Get HTTP client for direct API access
    */
@@ -192,7 +400,7 @@ var MemoryIntelligenceClient = class {
    * Analyze usage patterns and trends in memory collection
    */
   async analyzePatterns(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/analyze-patterns",
       {
         ...params,
@@ -202,13 +410,18 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to analyze patterns: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
   /**
    * Get AI-powered tag suggestions for a memory
    */
   async suggestTags(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/suggest-tags",
       {
         ...params,
@@ -218,13 +431,18 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to suggest tags: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
   /**
    * Find semantically related memories using vector similarity
    */
   async findRelated(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/find-related",
       {
         ...params,
@@ -234,13 +452,18 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to find related memories: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
   /**
    * Detect potential duplicate memories
    */
   async detectDuplicates(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/detect-duplicates",
       {
         ...params,
@@ -250,13 +473,18 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to detect duplicates: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
   /**
    * Extract insights and patterns from memories
    */
   async extractInsights(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/extract-insights",
       {
         ...params,
@@ -266,13 +494,18 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to extract insights: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
   /**
    * Check the health and organization quality of memories
    */
   async healthCheck(params) {
-    const response = await this.httpClient.post(
+    const response = await this.httpClient.postEnhanced(
       "/intelligence/health-check",
       {
         ...params,
@@ -282,7 +515,12 @@ var MemoryIntelligenceClient = class {
     if (response.error) {
       throw new DatabaseError(`Failed to check health: ${response.error.message}`);
     }
-    return response.data;
+    return {
+      data: response.data,
+      usage: response.usage,
+      tier_info: response.tier_info,
+      fromCache: response.fromCache
+    };
   }
 };
 var ResponseFormat = {
@@ -320,7 +558,7 @@ function createMCPServer(config) {
   const client = new MemoryIntelligenceClient(config);
   const server = new McpServer({
     name: "memory-intelligence-mcp-server",
-    version: "1.0.0"
+    version: "1.1.0"
   });
   server.registerTool(
     "memory_analyze_patterns",
@@ -346,7 +584,8 @@ function createMCPServer(config) {
           timeRangeDays: rawParams.time_range_days,
           responseFormat: rawParams.response_format
         };
-        const analysis = await client.analyzePatterns(params);
+        const response = await client.analyzePatterns(params);
+        const analysis = response.data;
         const responseText = formatResponse(
           analysis,
           params.responseFormat || "markdown",
@@ -436,7 +675,8 @@ function createMCPServer(config) {
           includeExistingTags: rawParams.include_existing_tags,
           responseFormat: rawParams.response_format
         };
-        const result = await client.suggestTags(params);
+        const response = await client.suggestTags(params);
+        const result = response.data;
         const responseText = formatResponse(
           result,
           params.responseFormat || "markdown",
@@ -505,7 +745,8 @@ function createMCPServer(config) {
           similarityThreshold: rawParams.similarity_threshold,
           responseFormat: rawParams.response_format
         };
-        const result = await client.findRelated(params);
+        const response = await client.findRelated(params);
+        const result = response.data;
         const responseText = formatResponse(
           result,
           params.responseFormat || "markdown",
@@ -576,7 +817,8 @@ function createMCPServer(config) {
           maxPairs: rawParams.max_pairs,
           responseFormat: rawParams.response_format
         };
-        const result = await client.detectDuplicates(params);
+        const response = await client.detectDuplicates(params);
+        const result = response.data;
         const responseText = formatResponse(
           result,
           params.responseFormat || "markdown",
@@ -649,7 +891,8 @@ function createMCPServer(config) {
           maxMemories: rawParams.max_memories,
           responseFormat: rawParams.response_format
         };
-        const result = await client.extractInsights(params);
+        const response = await client.extractInsights(params);
+        const result = response.data;
         const responseText = formatResponse(
           result,
           params.responseFormat || "markdown",
@@ -670,14 +913,15 @@ ${data.summary}
 `;
             md += `## Insights
 `;
+            const categoryIcons = {
+              pattern: "\u{1F504}",
+              learning: "\u{1F4A1}",
+              opportunity: "\u{1F680}",
+              risk: "\u26A0\uFE0F",
+              action_item: "\u2705"
+            };
             for (const insight of data.insights) {
-              const icon = {
-                pattern: "\u{1F504}",
-                learning: "\u{1F4A1}",
-                opportunity: "\u{1F680}",
-                risk: "\u26A0\uFE0F",
-                action_item: "\u2705"
-              }[insight.category] || "\u{1F4CC}";
+              const icon = categoryIcons[insight.category] || "\u{1F4CC}";
               md += `
 ### ${icon} ${insight.title}
 `;
@@ -727,7 +971,8 @@ ${data.summary}
           userId: rawParams.user_id,
           responseFormat: rawParams.response_format
         };
-        const result = await client.healthCheck(params);
+        const response = await client.healthCheck(params);
+        const result = response.data;
         const responseText = formatResponse(
           result,
           params.responseFormat || "markdown",