@usewhisper/sdk 2.1.0 → 2.2.1

package/index.mjs

@@ -117,7 +117,7 @@ ${context}` : "",
         if (extractedMemories.length > 0) {
           const bulk = await this.client.addMemoriesBulk({
             project: options?.project ?? this.options.project,
-            async: false,
+            write_mode: "async",
             memories: extractedMemories.map((m) => ({
               content: m.content,
               memory_type: m.memoryType,
@@ -185,6 +185,10 @@ ${context}` : "",
         extracted: result?.memories_created ?? 0
       };
     } catch (error) {
+      const fallback = await this.fallbackCaptureViaAddMemory(messages, options);
+      if (fallback.success) {
+        return fallback;
+      }
       console.error("[Whisper] Session capture failed:", error);
       return { success: false, extracted: 0 };
     }
@@ -242,6 +246,28 @@ User: ${params.userMessage}` : params.userMessage;
     }
     return Array.from(new Set(ids));
   }
+  async fallbackCaptureViaAddMemory(messages, options) {
+    const userMessages = messages.filter((m) => m.role === "user").map((m) => (m.content || "").trim()).filter((content) => content.length >= 5).slice(-2);
+    if (userMessages.length === 0) {
+      return { success: false, extracted: 0 };
+    }
+    let extracted = 0;
+    for (const content of userMessages) {
+      try {
+        await this.client.addMemory({
+          project: options?.project ?? this.options.project,
+          content,
+          memory_type: "factual",
+          user_id: options?.userId ?? this.userId,
+          session_id: options?.sessionId ?? this.sessionId,
+          allow_legacy_fallback: true
+        });
+        extracted += 1;
+      } catch {
+      }
+    }
+    return { success: extracted > 0, extracted };
+  }
 };
 var whisper_agent_default = Whisper;
 
@@ -314,6 +340,31 @@ function createAgentMiddleware(config) {
   return new WhisperAgentMiddleware(config);
 }
 
+// ../src/sdk/graph-utils.ts
+function sanitizeId(id) {
+  return `n_${id.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+function shortLabel(input, max = 48) {
+  const text = (input || "").replace(/\s+/g, " ").trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 3)}...`;
+}
+function memoryGraphToMermaid(graph) {
+  const lines = ["flowchart LR"];
+  for (const node of graph.nodes || []) {
+    const sid = sanitizeId(node.id);
+    const label = shortLabel(node.label || node.id);
+    lines.push(`  ${sid}["${label.replace(/"/g, '\\"')}"]`);
+  }
+  for (const edge of graph.edges || []) {
+    const s = sanitizeId(edge.source);
+    const t = sanitizeId(edge.target);
+    const rel = shortLabel(edge.type || "rel", 18).replace(/"/g, '\\"');
+    lines.push(`  ${s} -->|${rel}| ${t}`);
+  }
+  return lines.join("\n");
+}
+
 // ../src/sdk/index.ts
 var WhisperError = class extends Error {
   code;
@@ -358,6 +409,10 @@ function normalizeEndpoint(endpoint) {
   }
   return withLeadingSlash;
 }
+function isProjectNotFoundMessage(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("project not found") || normalized.includes("no project found") || normalized.includes("project does not exist");
+}
 var WhisperContext = class _WhisperContext {
   apiKey;
   baseUrl;
@@ -464,9 +519,17 @@ var WhisperContext = class _WhisperContext {
     return Array.from(candidates).filter(Boolean);
   }
   async withProjectRefFallback(projectRef, execute) {
+    try {
+      return await execute(projectRef);
+    } catch (error) {
+      if (!(error instanceof WhisperError) || error.code !== "PROJECT_NOT_FOUND") {
+        throw error;
+      }
+    }
     const refs = await this.getProjectRefCandidates(projectRef);
     let lastError;
     for (const ref of refs) {
+      if (ref === projectRef) continue;
       try {
         return await execute(ref);
       } catch (error) {
@@ -489,7 +552,7 @@ var WhisperContext = class _WhisperContext {
     if (status === 401 || /api key|unauthorized|forbidden/i.test(message)) {
       return { code: "INVALID_API_KEY", retryable: false };
     }
-    if (status === 404 || /project not found/i.test(message)) {
+    if (status === 404 && isProjectNotFoundMessage(message)) {
       return { code: "PROJECT_NOT_FOUND", retryable: false };
     }
     if (status === 408) {
@@ -503,6 +566,16 @@ var WhisperContext = class _WhisperContext {
     }
     return { code: "REQUEST_FAILED", retryable: false };
   }
+  isEndpointNotFoundError(error) {
+    if (!(error instanceof WhisperError)) {
+      return false;
+    }
+    if (error.status !== 404) {
+      return false;
+    }
+    const message = (error.message || "").toLowerCase();
+    return !isProjectNotFoundMessage(message);
+  }
   async request(endpoint, options = {}) {
     const maxAttempts = Math.max(1, this.retryConfig.maxAttempts);
     const normalizedEndpoint = normalizeEndpoint(endpoint);
@@ -536,7 +609,11 @@ var WhisperContext = class _WhisperContext {
           } catch {
             payload = await response.text().catch(() => "");
           }
-          const message = typeof payload === "string" ? payload : payload?.error || payload?.message || `HTTP ${response.status}: ${response.statusText}`;
+          let message = typeof payload === "string" ? payload : payload?.error || payload?.message || `HTTP ${response.status}: ${response.statusText}`;
+          if (response.status === 404 && !isProjectNotFoundMessage(message)) {
+            const endpointHint = `${this.baseUrl}${normalizedEndpoint}`;
+            message = `Endpoint not found at ${endpointHint}. This deployment may not support this API route.`;
+          }
           const { code, retryable } = this.classifyError(response.status, message);
           const err = new WhisperError({
             code,
@@ -679,13 +756,18 @@ var WhisperContext = class _WhisperContext {
             session_id: params.session_id,
             agent_id: params.agent_id,
             importance: params.importance,
-            metadata: params.metadata
+            metadata: params.metadata,
+            async: params.async,
+            write_mode: params.write_mode
           })
         });
-        const id2 = direct?.memory?.id || direct?.id || direct?.memory_id;
+        const id2 = direct?.memory?.id || direct?.id || direct?.memory_id || direct?.job_id;
         if (id2) {
           return { id: id2, success: true, path: "sota", fallback_used: false };
         }
+        if (direct?.success === true) {
+          return { id: "", success: true, path: "sota", fallback_used: false };
+        }
       } catch (error) {
         if (params.allow_legacy_fallback === false) {
           throw error;
@@ -717,10 +799,40 @@ var WhisperContext = class _WhisperContext {
   }
   async addMemoriesBulk(params) {
     const projectRef = this.getRequiredProject(params.project);
-    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/bulk", {
-      method: "POST",
-      body: JSON.stringify({ ...params, project })
-    }));
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      try {
+        return await this.request("/v1/memory/bulk", {
+          method: "POST",
+          body: JSON.stringify({ ...params, project })
+        });
+      } catch (error) {
+        if (!this.isEndpointNotFoundError(error)) {
+          throw error;
+        }
+        const created = await Promise.all(
+          params.memories.map(
+            (memory) => this.addMemory({
+              project,
+              content: memory.content,
+              memory_type: memory.memory_type,
+              user_id: memory.user_id,
+              session_id: memory.session_id,
+              agent_id: memory.agent_id,
+              importance: memory.importance,
+              metadata: memory.metadata,
+              allow_legacy_fallback: true
+            })
+          )
+        );
+        return {
+          success: true,
+          created: created.length,
+          memories: created,
+          path: "legacy",
+          fallback_used: true
+        };
+      }
+    });
   }
   async extractMemories(params) {
     const projectRef = this.getRequiredProject(params.project);
@@ -745,17 +857,48 @@ var WhisperContext = class _WhisperContext {
   }
   async searchMemories(params) {
     const projectRef = this.getRequiredProject(params.project);
-    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/search", {
-      method: "POST",
-      body: JSON.stringify({
-        query: params.query,
-        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
-      })
-    }));
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      try {
+        return await this.request("/v1/memory/search", {
+          method: "POST",
+          body: JSON.stringify({
+            query: params.query,
+            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,
+            profile: params.profile,
+            include_pending: params.include_pending
+          })
+        });
+      } catch (error) {
+        if (!this.isEndpointNotFoundError(error)) {
+          throw error;
+        }
+        const legacyTypeMap = {
+          factual: "factual",
+          preference: "semantic",
+          event: "episodic",
+          relationship: "semantic",
+          opinion: "semantic",
+          goal: "semantic",
+          instruction: "procedural"
+        };
+        return this.request("/v1/memories/search", {
+          method: "POST",
+          body: JSON.stringify({
+            query: params.query,
+            project,
+            user_id: params.user_id,
+            session_id: params.session_id,
+            agent_id: params.agent_id,
+            memory_type: params.memory_type ? legacyTypeMap[params.memory_type] : void 0,
+            top_k: params.top_k || 10
+          })
+        });
+      }
+    });
   }
   async createApiKey(params) {
     return this.request("/v1/keys", {
@@ -771,10 +914,29 @@ var WhisperContext = class _WhisperContext {
   }
   async searchMemoriesSOTA(params) {
     const projectRef = this.getRequiredProject(params.project);
-    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/search", {
-      method: "POST",
-      body: JSON.stringify({ ...params, project })
-    }));
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      try {
+        return await this.request("/v1/memory/search", {
+          method: "POST",
+          body: JSON.stringify({ ...params, project })
+        });
+      } catch (error) {
+        if (!this.isEndpointNotFoundError(error)) {
+          throw error;
+        }
+        const firstType = params.memory_types?.[0];
+        return this.searchMemories({
+          project,
+          query: params.query,
+          user_id: params.user_id,
+          session_id: params.session_id,
+          memory_type: firstType,
+          top_k: params.top_k,
+          profile: params.profile,
+          include_pending: params.include_pending
+        });
+      }
+    });
   }
   async ingestSession(params) {
     const projectRef = this.getRequiredProject(params.project);
@@ -784,37 +946,116 @@ var WhisperContext = class _WhisperContext {
     }));
   }
   async getSessionMemories(params) {
-    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
-    const query = new URLSearchParams({
-      project,
-      ...params.limit && { limit: params.limit.toString() },
-      ...params.since_date && { since_date: params.since_date }
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      const query = new URLSearchParams({
+        project,
+        ...params.limit && { limit: params.limit.toString() },
+        ...params.since_date && { since_date: params.since_date },
+        ...params.include_pending !== void 0 && { include_pending: String(params.include_pending) }
+      });
+      try {
+        return await this.request(`/v1/memory/session/${params.session_id}?${query}`);
+      } catch (error) {
+        if (!this.isEndpointNotFoundError(error)) {
+          throw error;
+        }
+        return { memories: [], count: 0 };
+      }
     });
-    return this.request(`/v1/memory/session/${params.session_id}?${query}`);
   }
   async getUserProfile(params) {
-    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
-    const query = new URLSearchParams({
-      project,
-      ...params.memory_types && { memory_types: params.memory_types }
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, async (project) => {
+      const query = new URLSearchParams({
+        project,
+        ...params.memory_types && { memory_types: params.memory_types },
+        ...params.include_pending !== void 0 && { include_pending: String(params.include_pending) }
+      });
+      try {
+        return await this.request(`/v1/memory/profile/${params.user_id}?${query}`);
+      } catch (error) {
+        if (!this.isEndpointNotFoundError(error)) {
+          throw error;
+        }
+        const legacyQuery = new URLSearchParams({
+          project,
+          user_id: params.user_id,
+          limit: "200"
+        });
+        const legacy = await this.request(`/v1/memories?${legacyQuery}`);
+        const memories = Array.isArray(legacy?.memories) ? legacy.memories : [];
+        return {
+          user_id: params.user_id,
+          memories,
+          count: memories.length
+        };
+      }
     });
-    return this.request(`/v1/memory/profile/${params.user_id}?${query}`);
   }
   async getMemoryVersions(memoryId) {
     return this.request(`/v1/memory/${memoryId}/versions`);
   }
   async updateMemory(memoryId, params) {
-    return this.request(`/v1/memory/${memoryId}`, {
-      method: "PUT",
-      body: JSON.stringify(params)
-    });
+    try {
+      return await this.request(`/v1/memory/${memoryId}`, {
+        method: "PUT",
+        body: JSON.stringify(params)
+      });
+    } catch (error) {
+      if (!this.isEndpointNotFoundError(error)) {
+        throw error;
+      }
+      const legacy = await this.request(`/v1/memories/${memoryId}`, {
+        method: "PUT",
+        body: JSON.stringify({
+          content: params.content
+        })
+      });
+      return {
+        success: true,
+        new_memory_id: legacy?.id || memoryId,
+        old_memory_id: memoryId
+      };
+    }
   }
   async deleteMemory(memoryId) {
-    return this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
+    try {
+      return await this.request(`/v1/memory/${memoryId}`, { method: "DELETE" });
+    } catch (error) {
+      if (!this.isEndpointNotFoundError(error)) {
+        throw error;
+      }
+      await this.request(`/v1/memories/${memoryId}`, { method: "DELETE" });
+      return {
+        success: true,
+        deleted: memoryId
+      };
+    }
   }
   async getMemoryRelations(memoryId) {
     return this.request(`/v1/memory/${memoryId}/relations`);
   }
+  async getMemoryGraph(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    const query = new URLSearchParams({
+      project,
+      ...params.user_id && { user_id: params.user_id },
+      ...params.session_id && { session_id: params.session_id },
+      ...params.include_inactive !== void 0 && { include_inactive: String(params.include_inactive) },
+      ...params.limit !== void 0 && { limit: String(params.limit) }
+    });
+    return this.request(`/v1/memory/graph?${query}`);
+  }
+  async getConversationGraph(params) {
+    const project = await this.resolveProjectId(this.getRequiredProject(params.project));
+    const query = new URLSearchParams({
+      project,
+      ...params.include_inactive !== void 0 && { include_inactive: String(params.include_inactive) },
+      ...params.limit !== void 0 && { limit: String(params.limit) }
+    });
+    return this.request(`/v1/memory/graph/conversation/${params.session_id}?${query}`);
+  }
   async oracleSearch(params) {
     const project = await this.resolveProjectId(this.getRequiredProject(params.project));
     return this.request("/v1/oracle/search", {
@@ -951,6 +1192,8 @@ var WhisperContext = class _WhisperContext {
     update: (memoryId, params) => this.updateMemory(memoryId, params),
     delete: (memoryId) => this.deleteMemory(memoryId),
     getRelations: (memoryId) => this.getMemoryRelations(memoryId),
+    getGraph: (params) => this.getMemoryGraph(params),
+    getConversationGraph: (params) => this.getConversationGraph(params),
     consolidate: (params) => this.consolidateMemories(params),
     updateDecay: (params) => this.updateImportanceDecay(params),
     getImportanceStats: (project) => this.getImportanceStats(project)
@@ -985,5 +1228,6 @@ export {
   whisper_agent_default as WhisperDefault,
   WhisperError,
   createAgentMiddleware,
-  index_default as default
+  index_default as default,
+  memoryGraphToMermaid
 };

package/package.json

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