@lanonasis/mem-intel-sdk 1.0.0 → 1.1.0

package/dist/react/hooks/useMemoryIntelligence.d.ts

@@ -2,11 +2,12 @@
  * React hooks for Memory Intelligence using React Query
  */
 import { UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
-import { PatternAnalysis, TagSuggestionsResult, RelatedMemoriesResult, DuplicatesResult, InsightsResult, MemoryHealth, AnalyzePatternsParams, SuggestTagsParams, FindRelatedParams, DetectDuplicatesParams, ExtractInsightsParams, HealthCheckParams } from "../../core/types";
+import { PatternAnalysis, TagSuggestionsResult, RelatedMemoriesResult, DuplicatesResult, InsightsResult, MemoryHealth, AnalyzePatternsParams, SuggestTagsParams, FindRelatedParams, DetectDuplicatesParams, ExtractInsightsParams, HealthCheckParams } from "../../core/types.js";
+import type { IntelligenceResponse } from "../../core/client.js";
 /**
  * Get the Memory Intelligence client from context
  */
-export declare function useMemoryIntelligence(): import("../../index-sdk").MemoryIntelligenceClient;
+export declare function useMemoryIntelligence(): import("../../index-sdk.js").MemoryIntelligenceClient;
 /**
  * Hook for analyzing memory patterns
  *
@@ -19,7 +20,7 @@ export declare function useMemoryIntelligence(): import("../../index-sdk").Memor
  * });
  * ```
  */
-export declare function usePatternAnalysis(params: AnalyzePatternsParams, options?: Omit<UseQueryOptions<PatternAnalysis>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<PatternAnalysis, Error>;
+export declare function usePatternAnalysis(params: AnalyzePatternsParams, options?: Omit<UseQueryOptions<IntelligenceResponse<PatternAnalysis>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<PatternAnalysis>, Error>;
 /**
  * Hook for getting tag suggestions
  *
@@ -32,7 +33,7 @@ export declare function usePatternAnalysis(params: AnalyzePatternsParams, option
  * });
  * ```
  */
-export declare function useTagSuggestions(params: SuggestTagsParams, options?: Omit<UseQueryOptions<TagSuggestionsResult>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<TagSuggestionsResult, Error>;
+export declare function useTagSuggestions(params: SuggestTagsParams, options?: Omit<UseQueryOptions<IntelligenceResponse<TagSuggestionsResult>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<TagSuggestionsResult>, Error>;
 /**
  * Mutation hook for getting tag suggestions (if you need manual trigger)
  *
@@ -47,7 +48,7 @@ export declare function useTagSuggestions(params: SuggestTagsParams, options?: O
  * });
  * ```
  */
-export declare function useTagSuggestionsMutation(options?: UseMutationOptions<TagSuggestionsResult, Error, SuggestTagsParams>): import("@tanstack/react-query").UseMutationResult<TagSuggestionsResult, Error, SuggestTagsParams, unknown>;
+export declare function useTagSuggestionsMutation(options?: UseMutationOptions<IntelligenceResponse<TagSuggestionsResult>, Error, SuggestTagsParams>): import("@tanstack/react-query").UseMutationResult<IntelligenceResponse<TagSuggestionsResult>, Error, SuggestTagsParams, unknown>;
 /**
  * Hook for finding related memories
  *
@@ -61,7 +62,7 @@ export declare function useTagSuggestionsMutation(options?: UseMutationOptions<T
  * });
  * ```
  */
-export declare function useRelatedMemories(params: FindRelatedParams, options?: Omit<UseQueryOptions<RelatedMemoriesResult>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<RelatedMemoriesResult, Error>;
+export declare function useRelatedMemories(params: FindRelatedParams, options?: Omit<UseQueryOptions<IntelligenceResponse<RelatedMemoriesResult>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<RelatedMemoriesResult>, Error>;
 /**
  * Hook for detecting duplicate memories
  *
@@ -74,11 +75,11 @@ export declare function useRelatedMemories(params: FindRelatedParams, options?:
  * });
  * ```
  */
-export declare function useDuplicateDetection(params: DetectDuplicatesParams, options?: Omit<UseQueryOptions<DuplicatesResult>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<DuplicatesResult, Error>;
+export declare function useDuplicateDetection(params: DetectDuplicatesParams, options?: Omit<UseQueryOptions<IntelligenceResponse<DuplicatesResult>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<DuplicatesResult>, Error>;
 /**
  * Mutation hook for duplicate detection (if you need manual trigger)
  */
-export declare function useDuplicateDetectionMutation(options?: UseMutationOptions<DuplicatesResult, Error, DetectDuplicatesParams>): import("@tanstack/react-query").UseMutationResult<DuplicatesResult, Error, DetectDuplicatesParams, unknown>;
+export declare function useDuplicateDetectionMutation(options?: UseMutationOptions<IntelligenceResponse<DuplicatesResult>, Error, DetectDuplicatesParams>): import("@tanstack/react-query").UseMutationResult<IntelligenceResponse<DuplicatesResult>, Error, DetectDuplicatesParams, unknown>;
 /**
  * Hook for extracting insights
  *
@@ -91,11 +92,11 @@ export declare function useDuplicateDetectionMutation(options?: UseMutationOptio
  * });
  * ```
  */
-export declare function useInsightExtraction(params: ExtractInsightsParams, options?: Omit<UseQueryOptions<InsightsResult>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<InsightsResult, Error>;
+export declare function useInsightExtraction(params: ExtractInsightsParams, options?: Omit<UseQueryOptions<IntelligenceResponse<InsightsResult>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<InsightsResult>, Error>;
 /**
  * Mutation hook for insight extraction (if you need manual trigger)
  */
-export declare function useInsightExtractionMutation(options?: UseMutationOptions<InsightsResult, Error, ExtractInsightsParams>): import("@tanstack/react-query").UseMutationResult<InsightsResult, Error, ExtractInsightsParams, unknown>;
+export declare function useInsightExtractionMutation(options?: UseMutationOptions<IntelligenceResponse<InsightsResult>, Error, ExtractInsightsParams>): import("@tanstack/react-query").UseMutationResult<IntelligenceResponse<InsightsResult>, Error, ExtractInsightsParams, unknown>;
 /**
  * Hook for checking memory health
  *
@@ -107,9 +108,9 @@ export declare function useInsightExtractionMutation(options?: UseMutationOption
  * });
  * ```
  */
-export declare function useHealthCheck(params: HealthCheckParams, options?: Omit<UseQueryOptions<MemoryHealth>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<MemoryHealth, Error>;
+export declare function useHealthCheck(params: HealthCheckParams, options?: Omit<UseQueryOptions<IntelligenceResponse<MemoryHealth>>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<IntelligenceResponse<MemoryHealth>, Error>;
 /**
  * Mutation hook for health check (if you need manual trigger)
  */
-export declare function useHealthCheckMutation(options?: UseMutationOptions<MemoryHealth, Error, HealthCheckParams>): import("@tanstack/react-query").UseMutationResult<MemoryHealth, Error, HealthCheckParams, unknown>;
+export declare function useHealthCheckMutation(options?: UseMutationOptions<IntelligenceResponse<MemoryHealth>, Error, HealthCheckParams>): import("@tanstack/react-query").UseMutationResult<IntelligenceResponse<MemoryHealth>, Error, HealthCheckParams, unknown>;
 //# sourceMappingURL=useMemoryIntelligence.d.ts.map

package/dist/react/hooks/useMemoryIntelligence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMemoryIntelligence.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useMemoryIntelligence.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAyB,eAAe,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEnG,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,wBAAgB,qBAAqB,uDAGpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,0EASzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,+EAS9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,CAAC,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,KAAK,EAAE,iBAAiB,CAAC,8GAQ7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,gFAS/E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,2EAS1E;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAC,gBAAgB,EAAE,KAAK,EAAE,sBAAsB,CAAC,+GAQ9E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,yEASxE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,CAAC,EAAE,kBAAkB,CAAC,cAAc,EAAE,KAAK,EAAE,qBAAqB,CAAC,4GAQ3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,uEAStE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,kBAAkB,CAAC,YAAY,EAAE,KAAK,EAAE,iBAAiB,CAAC,sGAQrE"}
+{"version":3,"file":"useMemoryIntelligence.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useMemoryIntelligence.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAyB,eAAe,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEnG,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE;;GAEG;AACH,wBAAgB,qBAAqB,0DAGpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,gGAS/F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,qGASpG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,CAAC,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,oIAQnG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,sGASrG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,iGAShG;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,sBAAsB,CAAC,qIAQpG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,+FAS9F;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,CAAC,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,qBAAqB,CAAC,kIAQjG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,6FAS5F;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,4HAQ3F"}

package/dist/react/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
 var reactQuery = require('@tanstack/react-query');
 var zod = require('zod');
 
@@ -50,12 +51,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");
@@ -68,11 +177,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}`;
@@ -132,6 +265,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);
   }
@@ -147,6 +317,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
@@ -154,20 +340,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
    */
@@ -199,7 +408,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,
@@ -209,13 +418,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,
@@ -225,13 +439,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,
@@ -241,13 +460,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,
@@ -257,13 +481,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,
@@ -273,13 +502,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,
@@ -289,20 +523,21 @@ 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
+    };
   }
 };
-
-// src/react/context/MemoryIntelligenceProvider.tsx
-var MemoryIntelligenceContext = React.createContext(
-  null
-);
+var MemoryIntelligenceContext = React.createContext(null);
 function MemoryIntelligenceProvider({
   config,
   children
 }) {
   const [client] = React__default.default.useState(() => new MemoryIntelligenceClient(config));
-  return /* @__PURE__ */ React__default.default.createElement(MemoryIntelligenceContext.Provider, { value: { client } }, children);
+  return /* @__PURE__ */ jsxRuntime.jsx(MemoryIntelligenceContext.Provider, { value: { client }, children });
 }
 function useMemoryIntelligenceContext() {
   const context = React.useContext(MemoryIntelligenceContext);