@usewhisper/sdk 1.0.1 → 1.1.0

package/index.d.mts

@@ -170,16 +170,19 @@ declare class WhisperContext {
     addMemory(params: {
         project?: string;
         content: string;
-        memory_type?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+        memory_type?: "factual" | "episodic" | "semantic" | "procedural" | "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;
+        allow_legacy_fallback?: boolean;
     }): Promise<{
         id: string;
         success: boolean;
+        path: "sota" | "legacy";
+        fallback_used: boolean;
     }>;
     searchMemories(params: {
         project?: string;
@@ -399,6 +402,56 @@ declare class WhisperContext {
         start_date?: string;
         end_date?: string;
     }): Promise<any>;
+    /**
+     * Semantic search over raw documents without pre-indexing.
+     * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+     * Perfect for AI agents to semantically explore a codebase on-the-fly.
+     */
+    semanticSearch(params: {
+        query: string;
+        documents: Array<{
+            id: string;
+            content: string;
+        }>;
+        top_k?: number;
+        threshold?: number;
+    }): Promise<{
+        results: Array<{
+            id: string;
+            score: number;
+            content: string;
+            snippet: string;
+        }>;
+        total_searched: number;
+        total_returned: number;
+        query: string;
+        latency_ms: number;
+    }>;
+    searchFiles(params: {
+        query: string;
+        path?: string;
+        mode?: "content" | "filename" | "both";
+        file_types?: string[];
+        max_results?: number;
+        context_lines?: number;
+        case_sensitive?: boolean;
+    }): Promise<{
+        results: Array<{
+            file: string;
+            matches: Array<{
+                line: number;
+                content: string;
+                context_before: string[];
+                context_after: string[];
+            }>;
+        }>;
+        total_files: number;
+        total_matches: number;
+        search_path: string;
+        mode: string;
+        latency_ms: number;
+        engine: "ripgrep" | "node";
+    }>;
     getCostSavings(params?: {
         project?: string;
         start_date?: string;
@@ -434,6 +487,8 @@ declare class WhisperContext {
         add: (params: Parameters<WhisperContext["addMemory"]>[0]) => Promise<{
             id: string;
             success: boolean;
+            path: "sota" | "legacy";
+            fallback_used: boolean;
         }>;
         search: (params: Parameters<WhisperContext["searchMemories"]>[0]) => Promise<any>;
         searchSOTA: (params: Parameters<WhisperContext["searchMemoriesSOTA"]>[0]) => Promise<any>;

package/index.d.ts

@@ -170,16 +170,19 @@ declare class WhisperContext {
     addMemory(params: {
         project?: string;
         content: string;
-        memory_type?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+        memory_type?: "factual" | "episodic" | "semantic" | "procedural" | "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;
+        allow_legacy_fallback?: boolean;
     }): Promise<{
         id: string;
         success: boolean;
+        path: "sota" | "legacy";
+        fallback_used: boolean;
     }>;
     searchMemories(params: {
         project?: string;
@@ -399,6 +402,56 @@ declare class WhisperContext {
         start_date?: string;
         end_date?: string;
     }): Promise<any>;
+    /**
+     * Semantic search over raw documents without pre-indexing.
+     * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+     * Perfect for AI agents to semantically explore a codebase on-the-fly.
+     */
+    semanticSearch(params: {
+        query: string;
+        documents: Array<{
+            id: string;
+            content: string;
+        }>;
+        top_k?: number;
+        threshold?: number;
+    }): Promise<{
+        results: Array<{
+            id: string;
+            score: number;
+            content: string;
+            snippet: string;
+        }>;
+        total_searched: number;
+        total_returned: number;
+        query: string;
+        latency_ms: number;
+    }>;
+    searchFiles(params: {
+        query: string;
+        path?: string;
+        mode?: "content" | "filename" | "both";
+        file_types?: string[];
+        max_results?: number;
+        context_lines?: number;
+        case_sensitive?: boolean;
+    }): Promise<{
+        results: Array<{
+            file: string;
+            matches: Array<{
+                line: number;
+                content: string;
+                context_before: string[];
+                context_after: string[];
+            }>;
+        }>;
+        total_files: number;
+        total_matches: number;
+        search_path: string;
+        mode: string;
+        latency_ms: number;
+        engine: "ripgrep" | "node";
+    }>;
     getCostSavings(params?: {
         project?: string;
         start_date?: string;
@@ -434,6 +487,8 @@ declare class WhisperContext {
         add: (params: Parameters<WhisperContext["addMemory"]>[0]) => Promise<{
             id: string;
             success: boolean;
+            path: "sota" | "legacy";
+            fallback_used: boolean;
         }>;
         search: (params: Parameters<WhisperContext["searchMemories"]>[0]) => Promise<any>;
         searchSOTA: (params: Parameters<WhisperContext["searchMemoriesSOTA"]>[0]) => Promise<any>;

package/index.js

@@ -332,13 +332,40 @@ var WhisperContext = class _WhisperContext {
   async addMemory(params) {
     const projectRef = this.getRequiredProject(params.project);
     return this.withProjectRefFallback(projectRef, async (project) => {
+      const toSotaType = (memoryType) => {
+        switch (memoryType) {
+          case "episodic":
+            return "event";
+          case "semantic":
+            return "factual";
+          case "procedural":
+            return "instruction";
+          default:
+            return memoryType;
+        }
+      };
+      const toLegacyType = (memoryType) => {
+        switch (memoryType) {
+          case "event":
+            return "episodic";
+          case "instruction":
+            return "procedural";
+          case "preference":
+          case "relationship":
+          case "opinion":
+          case "goal":
+            return "semantic";
+          default:
+            return memoryType;
+        }
+      };
       try {
         const direct = await this.request("/v1/memory", {
           method: "POST",
           body: JSON.stringify({
             project,
             content: params.content,
-            memory_type: params.memory_type,
+            memory_type: toSotaType(params.memory_type),
             user_id: params.user_id,
             session_id: params.session_id,
             agent_id: params.agent_id,
@@ -346,28 +373,37 @@ var WhisperContext = class _WhisperContext {
             metadata: params.metadata
           })
         });
-        const id = direct?.memory?.id || direct?.id || direct?.memory_id;
-        if (id) {
-          return { id, success: true };
+        const id2 = direct?.memory?.id || direct?.id || direct?.memory_id;
+        if (id2) {
+          return { id: id2, success: true, path: "sota", fallback_used: false };
+        }
+      } catch (error) {
+        if (params.allow_legacy_fallback === false) {
+          throw error;
         }
-      } catch {
       }
-      await this.request("/v1/memory/ingest/session", {
+      const legacy = await this.request("/v1/memories", {
         method: "POST",
         body: JSON.stringify({
           project,
-          session_id: params.session_id || `single-${Date.now()}`,
+          content: params.content,
+          memory_type: toLegacyType(params.memory_type),
           user_id: params.user_id,
-          messages: [
-            {
-              role: "user",
-              content: params.content,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          ]
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          metadata: params.metadata,
+          expires_in_seconds: params.expires_in_seconds
         })
       });
-      return { id: `session-${Date.now()}`, success: true };
+      const id = legacy?.memory?.id || legacy?.id || legacy?.memory_id;
+      if (!id) {
+        throw new WhisperError({
+          code: "REQUEST_FAILED",
+          message: "Memory create succeeded but no memory id was returned by the API"
+        });
+      }
+      return { id, success: true, path: "legacy", fallback_used: true };
     });
   }
   async searchMemories(params) {
@@ -526,6 +562,23 @@ var WhisperContext = class _WhisperContext {
     });
     return this.request(`/v1/cost/breakdown?${query}`);
   }
+  /**
+   * Semantic search over raw documents without pre-indexing.
+   * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+   * Perfect for AI agents to semantically explore a codebase on-the-fly.
+   */
+  async semanticSearch(params) {
+    return this.request("/v1/search/semantic", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async searchFiles(params) {
+    return this.request("/v1/search/files", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
   async getCostSavings(params = {}) {
     const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
     const query = new URLSearchParams({

package/index.mjs

@@ -306,13 +306,40 @@ var WhisperContext = class _WhisperContext {
   async addMemory(params) {
     const projectRef = this.getRequiredProject(params.project);
     return this.withProjectRefFallback(projectRef, async (project) => {
+      const toSotaType = (memoryType) => {
+        switch (memoryType) {
+          case "episodic":
+            return "event";
+          case "semantic":
+            return "factual";
+          case "procedural":
+            return "instruction";
+          default:
+            return memoryType;
+        }
+      };
+      const toLegacyType = (memoryType) => {
+        switch (memoryType) {
+          case "event":
+            return "episodic";
+          case "instruction":
+            return "procedural";
+          case "preference":
+          case "relationship":
+          case "opinion":
+          case "goal":
+            return "semantic";
+          default:
+            return memoryType;
+        }
+      };
       try {
         const direct = await this.request("/v1/memory", {
           method: "POST",
           body: JSON.stringify({
             project,
             content: params.content,
-            memory_type: params.memory_type,
+            memory_type: toSotaType(params.memory_type),
             user_id: params.user_id,
             session_id: params.session_id,
             agent_id: params.agent_id,
@@ -320,28 +347,37 @@ var WhisperContext = class _WhisperContext {
             metadata: params.metadata
           })
         });
-        const id = direct?.memory?.id || direct?.id || direct?.memory_id;
-        if (id) {
-          return { id, success: true };
+        const id2 = direct?.memory?.id || direct?.id || direct?.memory_id;
+        if (id2) {
+          return { id: id2, success: true, path: "sota", fallback_used: false };
+        }
+      } catch (error) {
+        if (params.allow_legacy_fallback === false) {
+          throw error;
         }
-      } catch {
       }
-      await this.request("/v1/memory/ingest/session", {
+      const legacy = await this.request("/v1/memories", {
         method: "POST",
         body: JSON.stringify({
           project,
-          session_id: params.session_id || `single-${Date.now()}`,
+          content: params.content,
+          memory_type: toLegacyType(params.memory_type),
           user_id: params.user_id,
-          messages: [
-            {
-              role: "user",
-              content: params.content,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          ]
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          metadata: params.metadata,
+          expires_in_seconds: params.expires_in_seconds
         })
       });
-      return { id: `session-${Date.now()}`, success: true };
+      const id = legacy?.memory?.id || legacy?.id || legacy?.memory_id;
+      if (!id) {
+        throw new WhisperError({
+          code: "REQUEST_FAILED",
+          message: "Memory create succeeded but no memory id was returned by the API"
+        });
+      }
+      return { id, success: true, path: "legacy", fallback_used: true };
     });
   }
   async searchMemories(params) {
@@ -500,6 +536,23 @@ var WhisperContext = class _WhisperContext {
     });
     return this.request(`/v1/cost/breakdown?${query}`);
   }
+  /**
+   * Semantic search over raw documents without pre-indexing.
+   * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+   * Perfect for AI agents to semantically explore a codebase on-the-fly.
+   */
+  async semanticSearch(params) {
+    return this.request("/v1/search/semantic", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async searchFiles(params) {
+    return this.request("/v1/search/files", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
   async getCostSavings(params = {}) {
     const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
     const query = new URLSearchParams({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usewhisper/sdk",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "scripts": {
     "build": "tsup ../src/sdk/index.ts --format esm,cjs --dts --out-dir .",
     "prepublishOnly": "npm run build"