@usewhisper/sdk 0.1.0 → 1.0.0

package/index.cjs

@@ -109,6 +109,199 @@ var WhisperContext = class {
   async getUsage(days = 30) {
     return this.request(`/v1/usage?days=${days}`);
   }
+  // ─── SOTA Memory System ─────────────────────────────────────────
+  /**
+   * SOTA Memory Search - Search memories with temporal and type filtering
+   */
+  async searchMemoriesSOTA(params) {
+    return this.request("/v1/memory/search", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Ingest Session - Create memories from a conversation
+   */
+  async ingestSession(params) {
+    return this.request("/v1/memory/ingest/session", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Session Memories - Recent memories from a session
+   */
+  async getSessionMemories(params) {
+    const query = new URLSearchParams({
+      project: params.project,
+      ...params.limit && { limit: params.limit.toString() },
+      ...params.since_date && { since_date: params.since_date }
+    });
+    return this.request(`/v1/memory/session/${params.session_id}?${query}`);
+  }
+  /**
+   * Get User Profile - Long-term user preferences and facts
+   */
+  async getUserProfile(params) {
+    const query = new URLSearchParams({
+      project: params.project,
+      ...params.memory_types && { memory_types: params.memory_types }
+    });
+    return this.request(`/v1/memory/profile/${params.user_id}?${query}`);
+  }
+  /**
+   * Get Memory Versions - Version chain history
+   */
+  async getMemoryVersions(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/versions`);
+  }
+  /**
+   * Update Memory - Create a new version
+   */
+  async updateMemory(memoryId, params) {
+    return this.request(`/v1/memory/${memoryId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete Memory - Soft delete
+   */
+  async deleteMemory(memoryId) {
+    return this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
+  }
+  /**
+   * Get Memory Relations - Graph connections
+   */
+  async getMemoryRelations(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/relations`);
+  }
+  // ─── Context Layer ──────────────────────────────────────────────
+  /**
+   * Oracle Search - Tree-guided document navigation with research mode
+   */
+  async oracleSearch(params) {
+    return this.request("/v1/oracle/search", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Autosubscribe - Auto-index project dependencies
+   */
+  async autosubscribe(params) {
+    return this.request("/v1/autosubscribe", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Create Shared Context - Save and share a conversation
+   */
+  async createSharedContext(params) {
+    return this.request("/v1/context/share", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Load Shared Context - View shared context (public endpoint)
+   */
+  async loadSharedContext(shareId) {
+    return this.request(`/v1/context/shared/${shareId}`);
+  }
+  /**
+   * Resume from Shared Context - Fork shared context to new session
+   */
+  async resumeFromSharedContext(params) {
+    return this.request("/v1/context/resume", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  // ─── Optimization ───────────────────────────────────────────────
+  /**
+   * Consolidate Memories - Find and merge duplicates
+   */
+  async consolidateMemories(params) {
+    return this.request("/v1/memory/consolidate", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Update Importance Decay - Apply time-based relevance scoring
+   */
+  async updateImportanceDecay(params) {
+    return this.request("/v1/memory/decay/update", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Importance Statistics
+   */
+  async getImportanceStats(project) {
+    return this.request(`/v1/memory/decay/stats?project=${project}`);
+  }
+  /**
+   * Get Cache Statistics
+   */
+  async getCacheStats() {
+    return this.request("/v1/cache/stats");
+  }
+  /**
+   * Warm Cache - Preload common queries
+   */
+  async warmCache(params) {
+    return this.request("/v1/cache/warm", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Clear Cache Pattern
+   */
+  async clearCache(params) {
+    return this.request("/v1/cache/clear", {
+      method: "DELETE",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Cost Summary - Cost tracking overview
+   */
+  async getCostSummary(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/summary?${query}`);
+  }
+  /**
+   * Get Cost Breakdown - Detailed cost analysis
+   */
+  async getCostBreakdown(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.group_by && { group_by: params.group_by },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/breakdown?${query}`);
+  }
+  /**
+   * Get Savings Report - Compare actual vs always-Opus costs
+   */
+  async getCostSavings(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/savings?${query}`);
+  }
 };
 var index_default = WhisperContext;
 // Annotate the CommonJS export names for ESM import in node:

package/index.d.cts

@@ -161,6 +161,272 @@ declare class WhisperContext {
         keys: any[];
     }>;
     getUsage(days?: number): Promise<any>;
+    /**
+     * SOTA Memory Search - Search memories with temporal and type filtering
+     */
+    searchMemoriesSOTA(params: {
+        query: string;
+        project: string;
+        user_id?: string;
+        session_id?: string;
+        question_date?: string;
+        top_k?: number;
+        memory_types?: Array<"factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction">;
+        include_inactive?: boolean;
+        include_chunks?: boolean;
+        include_relations?: boolean;
+    }): Promise<any>;
+    /**
+     * Ingest Session - Create memories from a conversation
+     */
+    ingestSession(params: {
+        project: string;
+        session_id: string;
+        user_id?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+        }>;
+    }): Promise<{
+        success: boolean;
+        memories_created: number;
+        relations_created: number;
+        memories_invalidated: number;
+        errors?: string[];
+    }>;
+    /**
+     * Get Session Memories - Recent memories from a session
+     */
+    getSessionMemories(params: {
+        session_id: string;
+        project: string;
+        limit?: number;
+        since_date?: string;
+    }): Promise<{
+        memories: any[];
+        count: number;
+    }>;
+    /**
+     * Get User Profile - Long-term user preferences and facts
+     */
+    getUserProfile(params: {
+        user_id: string;
+        project: string;
+        memory_types?: string;
+    }): Promise<{
+        user_id: string;
+        memories: any[];
+        count: number;
+    }>;
+    /**
+     * Get Memory Versions - Version chain history
+     */
+    getMemoryVersions(memoryId: string): Promise<{
+        memory_id: string;
+        versions: any[];
+        count: number;
+    }>;
+    /**
+     * Update Memory - Create a new version
+     */
+    updateMemory(memoryId: string, params: {
+        content: string;
+        reasoning?: string;
+    }): Promise<{
+        success: boolean;
+        new_memory_id: string;
+        old_memory_id: string;
+    }>;
+    /**
+     * Delete Memory - Soft delete
+     */
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+        deleted: string;
+    }>;
+    /**
+     * Get Memory Relations - Graph connections
+     */
+    getMemoryRelations(memoryId: string): Promise<{
+        memory_id: string;
+        relations: any[];
+        count: number;
+    }>;
+    /**
+     * Oracle Search - Tree-guided document navigation with research mode
+     */
+    oracleSearch(params: {
+        query: string;
+        project: string;
+        max_results?: number;
+        mode?: "search" | "research";
+        max_steps?: number;
+    }): Promise<any>;
+    /**
+     * Autosubscribe - Auto-index project dependencies
+     */
+    autosubscribe(params: {
+        project: string;
+        source: {
+            type: "github" | "local";
+            owner?: string;
+            repo?: string;
+            path?: string;
+        };
+        dependency_file?: "package.json" | "requirements.txt" | "Cargo.toml" | "go.mod" | "Gemfile";
+        index_limit?: number;
+        auto_sync?: boolean;
+    }): Promise<{
+        success: boolean;
+        discovered: number;
+        indexed: number;
+        errors: string[];
+        dependencies?: any[];
+        auto_sync_enabled: boolean;
+    }>;
+    /**
+     * Create Shared Context - Save and share a conversation
+     */
+    createSharedContext(params: {
+        session_id: string;
+        project: string;
+        title?: string;
+        include_memories?: boolean;
+        include_chunks?: boolean;
+        expiry_days?: number;
+    }): Promise<{
+        success: boolean;
+        share_id: string;
+        share_url: string;
+        title: string;
+        memories_count: number;
+        messages_count: number;
+        expires_at: string;
+    }>;
+    /**
+     * Load Shared Context - View shared context (public endpoint)
+     */
+    loadSharedContext(shareId: string): Promise<{
+        share_id: string;
+        title: string;
+        created_at: string;
+        expires_at: string;
+        memories: any[];
+        messages: any[];
+        chunks?: any[];
+        metadata: any;
+    }>;
+    /**
+     * Resume from Shared Context - Fork shared context to new session
+     */
+    resumeFromSharedContext(params: {
+        share_id: string;
+        project: string;
+        new_session_id?: string;
+    }): Promise<{
+        success: boolean;
+        session_id: string;
+        memories_restored: number;
+        messages_restored: number;
+        chunks_restored: number;
+    }>;
+    /**
+     * Consolidate Memories - Find and merge duplicates
+     */
+    consolidateMemories(params: {
+        project: string;
+        similarity_threshold?: number;
+        auto_merge?: boolean;
+        dry_run?: boolean;
+    }): Promise<any>;
+    /**
+     * Update Importance Decay - Apply time-based relevance scoring
+     */
+    updateImportanceDecay(params: {
+        project: string;
+        decay_function?: "exponential" | "linear" | "logarithmic";
+        half_life_days?: number;
+        access_boost?: number;
+        auto_archive?: boolean;
+        archive_threshold?: number;
+    }): Promise<{
+        success: boolean;
+        memories_updated: number;
+        average_importance: number;
+        memories_archived: number;
+        config: any;
+    }>;
+    /**
+     * Get Importance Statistics
+     */
+    getImportanceStats(project: string): Promise<{
+        project_id: string;
+        statistics: any;
+    }>;
+    /**
+     * Get Cache Statistics
+     */
+    getCacheStats(): Promise<{
+        cache_type: string;
+        hit_rate: number;
+        total_requests: number;
+        hits: number;
+        misses: number;
+        size_bytes: number;
+        keys_count: number;
+        average_latency_ms: number;
+        uptime_seconds: number;
+    }>;
+    /**
+     * Warm Cache - Preload common queries
+     */
+    warmCache(params: {
+        project: string;
+        queries: string[];
+        ttl_seconds?: number;
+    }): Promise<{
+        success: boolean;
+        queries_warmed: number;
+        errors: string[];
+        cache_size_increase_bytes: number;
+    }>;
+    /**
+     * Clear Cache Pattern
+     */
+    clearCache(params: {
+        pattern?: string;
+        clear_all?: boolean;
+    }): Promise<{
+        success: boolean;
+        keys_cleared: number;
+        bytes_freed: number;
+    }>;
+    /**
+     * Get Cost Summary - Cost tracking overview
+     */
+    getCostSummary(params: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    /**
+     * Get Cost Breakdown - Detailed cost analysis
+     */
+    getCostBreakdown(params: {
+        project?: string;
+        group_by?: "model" | "task" | "day" | "hour";
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    /**
+     * Get Savings Report - Compare actual vs always-Opus costs
+     */
+    getCostSavings(params: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
 }
 
 export { type Memory, type Project, type QueryParams, type QueryResult, type Source, type WhisperConfig, WhisperContext, WhisperContext as default };

package/index.d.ts

@@ -123,30 +123,55 @@ declare class WhisperContext {
     }>): Promise<{
         ingested: number;
     }>;
+    /**
+     * Add Context - Quick method to inject context without full document format
+     * Ideal for agents to add context on the fly
+     *
+     * @example
+     * await client.addContext({
+     *   project: "my-app",
+     *   content: "User prefers dark mode and TypeScript over JavaScript"
+     * });
+     */
+    addContext(params: {
+        project: string;
+        content: string;
+        title?: string;
+        metadata?: Record<string, any>;
+    }): Promise<{
+        ingested: number;
+    }>;
+    /**
+     * Add Memory - Creates a memory using the SOTA memory system
+     * This is the recommended method for conversational memory
+     */
     addMemory(params: {
         project: string;
         content: string;
-        memory_type?: "factual" | "episodic" | "semantic" | "procedural";
+        memory_type?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
         user_id?: string;
         session_id?: string;
         agent_id?: string;
         importance?: number;
         metadata?: Record<string, any>;
         expires_in_seconds?: number;
-    }): Promise<Memory>;
+    }): Promise<{
+        id: string;
+        success: boolean;
+    }>;
+    /**
+     * Search Memories - Searches memories using SOTA memory search with temporal reasoning
+     * This is the recommended method for memory retrieval
+     */
     searchMemories(params: {
         project: string;
         query: string;
         user_id?: string;
         session_id?: string;
         agent_id?: string;
-        memory_type?: "factual" | "episodic" | "semantic" | "procedural";
+        memory_type?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
         top_k?: number;
-    }): Promise<{
-        memories: Array<Memory & {
-            score: number;
-        }>;
-    }>;
+    }): Promise<any>;
     createApiKey(params: {
         name: string;
         scopes?: string[];
@@ -161,6 +186,272 @@ declare class WhisperContext {
         keys: any[];
     }>;
     getUsage(days?: number): Promise<any>;
+    /**
+     * SOTA Memory Search - Search memories with temporal and type filtering
+     */
+    searchMemoriesSOTA(params: {
+        query: string;
+        project: string;
+        user_id?: string;
+        session_id?: string;
+        question_date?: string;
+        top_k?: number;
+        memory_types?: Array<"factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction">;
+        include_inactive?: boolean;
+        include_chunks?: boolean;
+        include_relations?: boolean;
+    }): Promise<any>;
+    /**
+     * Ingest Session - Create memories from a conversation
+     */
+    ingestSession(params: {
+        project: string;
+        session_id: string;
+        user_id?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+        }>;
+    }): Promise<{
+        success: boolean;
+        memories_created: number;
+        relations_created: number;
+        memories_invalidated: number;
+        errors?: string[];
+    }>;
+    /**
+     * Get Session Memories - Recent memories from a session
+     */
+    getSessionMemories(params: {
+        session_id: string;
+        project: string;
+        limit?: number;
+        since_date?: string;
+    }): Promise<{
+        memories: any[];
+        count: number;
+    }>;
+    /**
+     * Get User Profile - Long-term user preferences and facts
+     */
+    getUserProfile(params: {
+        user_id: string;
+        project: string;
+        memory_types?: string;
+    }): Promise<{
+        user_id: string;
+        memories: any[];
+        count: number;
+    }>;
+    /**
+     * Get Memory Versions - Version chain history
+     */
+    getMemoryVersions(memoryId: string): Promise<{
+        memory_id: string;
+        versions: any[];
+        count: number;
+    }>;
+    /**
+     * Update Memory - Create a new version
+     */
+    updateMemory(memoryId: string, params: {
+        content: string;
+        reasoning?: string;
+    }): Promise<{
+        success: boolean;
+        new_memory_id: string;
+        old_memory_id: string;
+    }>;
+    /**
+     * Delete Memory - Soft delete
+     */
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+        deleted: string;
+    }>;
+    /**
+     * Get Memory Relations - Graph connections
+     */
+    getMemoryRelations(memoryId: string): Promise<{
+        memory_id: string;
+        relations: any[];
+        count: number;
+    }>;
+    /**
+     * Oracle Search - Tree-guided document navigation with research mode
+     */
+    oracleSearch(params: {
+        query: string;
+        project: string;
+        max_results?: number;
+        mode?: "search" | "research";
+        max_steps?: number;
+    }): Promise<any>;
+    /**
+     * Autosubscribe - Auto-index project dependencies
+     */
+    autosubscribe(params: {
+        project: string;
+        source: {
+            type: "github" | "local";
+            owner?: string;
+            repo?: string;
+            path?: string;
+        };
+        dependency_file?: "package.json" | "requirements.txt" | "Cargo.toml" | "go.mod" | "Gemfile";
+        index_limit?: number;
+        auto_sync?: boolean;
+    }): Promise<{
+        success: boolean;
+        discovered: number;
+        indexed: number;
+        errors: string[];
+        dependencies?: any[];
+        auto_sync_enabled: boolean;
+    }>;
+    /**
+     * Create Shared Context - Save and share a conversation
+     */
+    createSharedContext(params: {
+        session_id: string;
+        project: string;
+        title?: string;
+        include_memories?: boolean;
+        include_chunks?: boolean;
+        expiry_days?: number;
+    }): Promise<{
+        success: boolean;
+        share_id: string;
+        share_url: string;
+        title: string;
+        memories_count: number;
+        messages_count: number;
+        expires_at: string;
+    }>;
+    /**
+     * Load Shared Context - View shared context (public endpoint)
+     */
+    loadSharedContext(shareId: string): Promise<{
+        share_id: string;
+        title: string;
+        created_at: string;
+        expires_at: string;
+        memories: any[];
+        messages: any[];
+        chunks?: any[];
+        metadata: any;
+    }>;
+    /**
+     * Resume from Shared Context - Fork shared context to new session
+     */
+    resumeFromSharedContext(params: {
+        share_id: string;
+        project: string;
+        new_session_id?: string;
+    }): Promise<{
+        success: boolean;
+        session_id: string;
+        memories_restored: number;
+        messages_restored: number;
+        chunks_restored: number;
+    }>;
+    /**
+     * Consolidate Memories - Find and merge duplicates
+     */
+    consolidateMemories(params: {
+        project: string;
+        similarity_threshold?: number;
+        auto_merge?: boolean;
+        dry_run?: boolean;
+    }): Promise<any>;
+    /**
+     * Update Importance Decay - Apply time-based relevance scoring
+     */
+    updateImportanceDecay(params: {
+        project: string;
+        decay_function?: "exponential" | "linear" | "logarithmic";
+        half_life_days?: number;
+        access_boost?: number;
+        auto_archive?: boolean;
+        archive_threshold?: number;
+    }): Promise<{
+        success: boolean;
+        memories_updated: number;
+        average_importance: number;
+        memories_archived: number;
+        config: any;
+    }>;
+    /**
+     * Get Importance Statistics
+     */
+    getImportanceStats(project: string): Promise<{
+        project_id: string;
+        statistics: any;
+    }>;
+    /**
+     * Get Cache Statistics
+     */
+    getCacheStats(): Promise<{
+        cache_type: string;
+        hit_rate: number;
+        total_requests: number;
+        hits: number;
+        misses: number;
+        size_bytes: number;
+        keys_count: number;
+        average_latency_ms: number;
+        uptime_seconds: number;
+    }>;
+    /**
+     * Warm Cache - Preload common queries
+     */
+    warmCache(params: {
+        project: string;
+        queries: string[];
+        ttl_seconds?: number;
+    }): Promise<{
+        success: boolean;
+        queries_warmed: number;
+        errors: string[];
+        cache_size_increase_bytes: number;
+    }>;
+    /**
+     * Clear Cache Pattern
+     */
+    clearCache(params: {
+        pattern?: string;
+        clear_all?: boolean;
+    }): Promise<{
+        success: boolean;
+        keys_cleared: number;
+        bytes_freed: number;
+    }>;
+    /**
+     * Get Cost Summary - Cost tracking overview
+     */
+    getCostSummary(params: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    /**
+     * Get Cost Breakdown - Detailed cost analysis
+     */
+    getCostBreakdown(params: {
+        project?: string;
+        group_by?: "model" | "task" | "day" | "hour";
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    /**
+     * Get Savings Report - Compare actual vs always-Opus costs
+     */
+    getCostSavings(params: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
 }
 
 export { type Memory, type Project, type QueryParams, type QueryResult, type Source, type WhisperConfig, WhisperContext, WhisperContext as default };

package/index.js

@@ -1,4 +1,29 @@
-// src/sdk/index.ts
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../src/sdk/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WhisperContext: () => WhisperContext,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
 var WhisperContext = class {
   apiKey;
   baseUrl;
@@ -60,16 +85,66 @@ var WhisperContext = class {
       body: JSON.stringify({ documents })
     });
   }
+  /**
+   * Add Context - Quick method to inject context without full document format
+   * Ideal for agents to add context on the fly
+   *
+   * @example
+   * await client.addContext({
+   *   project: "my-app",
+   *   content: "User prefers dark mode and TypeScript over JavaScript"
+   * });
+   */
+  async addContext(params) {
+    const projectData = await this.listProjects();
+    const project = projectData.projects.find(
+      (p) => p.name === params.project || p.slug === params.project
+    );
+    if (!project) {
+      throw new Error(`Project '${params.project}' not found`);
+    }
+    return this.ingest(project.id, [
+      {
+        title: params.title || "Context",
+        content: params.content,
+        metadata: params.metadata || { source: "addContext" }
+      }
+    ]);
+  }
+  /**
+   * Add Memory - Creates a memory using the SOTA memory system
+   * This is the recommended method for conversational memory
+   */
   async addMemory(params) {
-    return this.request("/v1/memories", {
+    return this.request("/v1/memory/ingest/session", {
       method: "POST",
-      body: JSON.stringify(params)
+      body: JSON.stringify({
+        project: params.project,
+        session_id: params.session_id || `single-${Date.now()}`,
+        user_id: params.user_id,
+        messages: [{
+          role: "user",
+          content: params.content,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }]
+      })
     });
   }
+  /**
+   * Search Memories - Searches memories using SOTA memory search with temporal reasoning
+   * This is the recommended method for memory retrieval
+   */
   async searchMemories(params) {
-    return this.request("/v1/memories/search", {
+    return this.request("/v1/memory/search", {
       method: "POST",
-      body: JSON.stringify(params)
+      body: JSON.stringify({
+        query: params.query,
+        project: params.project,
+        user_id: params.user_id,
+        session_id: params.session_id,
+        memory_types: params.memory_type ? [params.memory_type] : void 0,
+        top_k: params.top_k || 10
+      })
     });
   }
   async createApiKey(params) {
@@ -84,9 +159,202 @@ var WhisperContext = class {
   async getUsage(days = 30) {
     return this.request(`/v1/usage?days=${days}`);
   }
+  // ─── SOTA Memory System ─────────────────────────────────────────
+  /**
+   * SOTA Memory Search - Search memories with temporal and type filtering
+   */
+  async searchMemoriesSOTA(params) {
+    return this.request("/v1/memory/search", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Ingest Session - Create memories from a conversation
+   */
+  async ingestSession(params) {
+    return this.request("/v1/memory/ingest/session", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Session Memories - Recent memories from a session
+   */
+  async getSessionMemories(params) {
+    const query = new URLSearchParams({
+      project: params.project,
+      ...params.limit && { limit: params.limit.toString() },
+      ...params.since_date && { since_date: params.since_date }
+    });
+    return this.request(`/v1/memory/session/${params.session_id}?${query}`);
+  }
+  /**
+   * Get User Profile - Long-term user preferences and facts
+   */
+  async getUserProfile(params) {
+    const query = new URLSearchParams({
+      project: params.project,
+      ...params.memory_types && { memory_types: params.memory_types }
+    });
+    return this.request(`/v1/memory/profile/${params.user_id}?${query}`);
+  }
+  /**
+   * Get Memory Versions - Version chain history
+   */
+  async getMemoryVersions(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/versions`);
+  }
+  /**
+   * Update Memory - Create a new version
+   */
+  async updateMemory(memoryId, params) {
+    return this.request(`/v1/memory/${memoryId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete Memory - Soft delete
+   */
+  async deleteMemory(memoryId) {
+    return this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
+  }
+  /**
+   * Get Memory Relations - Graph connections
+   */
+  async getMemoryRelations(memoryId) {
+    return this.request(`/v1/memory/${memoryId}/relations`);
+  }
+  // ─── Context Layer ──────────────────────────────────────────────
+  /**
+   * Oracle Search - Tree-guided document navigation with research mode
+   */
+  async oracleSearch(params) {
+    return this.request("/v1/oracle/search", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Autosubscribe - Auto-index project dependencies
+   */
+  async autosubscribe(params) {
+    return this.request("/v1/autosubscribe", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Create Shared Context - Save and share a conversation
+   */
+  async createSharedContext(params) {
+    return this.request("/v1/context/share", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Load Shared Context - View shared context (public endpoint)
+   */
+  async loadSharedContext(shareId) {
+    return this.request(`/v1/context/shared/${shareId}`);
+  }
+  /**
+   * Resume from Shared Context - Fork shared context to new session
+   */
+  async resumeFromSharedContext(params) {
+    return this.request("/v1/context/resume", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  // ─── Optimization ───────────────────────────────────────────────
+  /**
+   * Consolidate Memories - Find and merge duplicates
+   */
+  async consolidateMemories(params) {
+    return this.request("/v1/memory/consolidate", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Update Importance Decay - Apply time-based relevance scoring
+   */
+  async updateImportanceDecay(params) {
+    return this.request("/v1/memory/decay/update", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Importance Statistics
+   */
+  async getImportanceStats(project) {
+    return this.request(`/v1/memory/decay/stats?project=${project}`);
+  }
+  /**
+   * Get Cache Statistics
+   */
+  async getCacheStats() {
+    return this.request("/v1/cache/stats");
+  }
+  /**
+   * Warm Cache - Preload common queries
+   */
+  async warmCache(params) {
+    return this.request("/v1/cache/warm", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Clear Cache Pattern
+   */
+  async clearCache(params) {
+    return this.request("/v1/cache/clear", {
+      method: "DELETE",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get Cost Summary - Cost tracking overview
+   */
+  async getCostSummary(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/summary?${query}`);
+  }
+  /**
+   * Get Cost Breakdown - Detailed cost analysis
+   */
+  async getCostBreakdown(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.group_by && { group_by: params.group_by },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/breakdown?${query}`);
+  }
+  /**
+   * Get Savings Report - Compare actual vs always-Opus costs
+   */
+  async getCostSavings(params) {
+    const query = new URLSearchParams({
+      ...params.project && { project: params.project },
+      ...params.start_date && { start_date: params.start_date },
+      ...params.end_date && { end_date: params.end_date }
+    });
+    return this.request(`/v1/cost/savings?${query}`);
+  }
 };
 var index_default = WhisperContext;
-export {
-  WhisperContext,
-  index_default as default
-};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WhisperContext
+});

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@usewhisper/sdk",
-  "version": "0.1.0",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "tsup ../src/sdk/index.ts --format esm,cjs --dts --out-dir .",
+    "prepublishOnly": "npm run build"
+  },
   "description": "TypeScript SDK for Whisper Context API - Add reliable context to your AI agents",
   "main": "index.cjs",
   "module": "index.js",
   "types": "index.d.ts",
   "exports": {
     ".": {
+      "types": "./index.d.ts",
       "import": "./index.js",
-      "require": "./index.cjs",
-      "types": "./index.d.ts"
+      "require": "./index.cjs"
     }
   },
   "files": [
@@ -34,7 +38,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Alixus/whisper"
+    "url": "https://github.com/Alixus/"
   },
   "homepage": "https://usewhisper.dev",
   "bugs": {