@usewhisper/sdk 2.0.0 → 2.2.0

package/index.mjs

@@ -13,7 +13,6 @@ var Whisper = class {
       baseUrl: options.baseUrl,
       project: options.project || "default"
     };
-    if (options.orgId) clientConfig.orgId = options.orgId;
     if (options.timeoutMs) clientConfig.timeoutMs = options.timeoutMs;
     if (options.retry) clientConfig.retry = options.retry;
     this.client = new WhisperContext(clientConfig);
@@ -22,12 +21,14 @@ var Whisper = class {
       apiKey: options.apiKey,
       baseUrl: options.baseUrl || "https://context.usewhisper.dev",
       project: options.project || "default",
-      orgId: options.orgId || "",
       timeoutMs: options.timeoutMs || 15e3,
       retry: finalRetry,
       contextLimit: options.contextLimit ?? 10,
       memoryTypes: options.memoryTypes ?? ["factual", "preference", "event", "goal", "relationship", "opinion", "instruction"],
-      contextPrefix: options.contextPrefix ?? "Relevant context:"
+      contextPrefix: options.contextPrefix ?? "Relevant context:",
+      autoExtract: options.autoExtract ?? true,
+      autoExtractMinConfidence: options.autoExtractMinConfidence ?? 0.65,
+      maxMemoriesPerCapture: options.maxMemoriesPerCapture ?? 5
     };
   }
   /**
@@ -102,6 +103,47 @@ ${context}` : "",
       return { success: false };
     }
     try {
+      if (this.options.autoExtract) {
+        const extraction = await this.client.extractMemories({
+          project: options?.project ?? this.options.project,
+          message: content,
+          user_id: options?.userId ?? this.userId,
+          session_id: options?.sessionId ?? this.sessionId,
+          enable_pattern: true,
+          enable_inference: true,
+          min_confidence: this.options.autoExtractMinConfidence
+        });
+        const extractedMemories = (extraction.all || []).filter((m) => (m.confidence || 0) >= this.options.autoExtractMinConfidence).slice(0, this.options.maxMemoriesPerCapture);
+        if (extractedMemories.length > 0) {
+          const bulk = await this.client.addMemoriesBulk({
+            project: options?.project ?? this.options.project,
+            async: false,
+            memories: extractedMemories.map((m) => ({
+              content: m.content,
+              memory_type: m.memoryType,
+              user_id: options?.userId ?? this.userId,
+              session_id: options?.sessionId ?? this.sessionId,
+              importance: Math.max(0.5, Math.min(1, m.confidence || 0.7)),
+              confidence: m.confidence || 0.7,
+              entity_mentions: m.entityMentions || [],
+              event_date: m.eventDate || void 0,
+              metadata: {
+                extracted: true,
+                extraction_method: extraction.extractionMethod,
+                extraction_reasoning: m.reasoning,
+                inferred: Boolean(m.inferred)
+              }
+            }))
+          });
+          const memoryIds = this.extractMemoryIdsFromBulkResponse(bulk);
+          return {
+            success: true,
+            memoryId: memoryIds[0],
+            memoryIds: memoryIds.length > 0 ? memoryIds : void 0,
+            extracted: extractedMemories.length
+          };
+        }
+      }
       const result = await this.client.addMemory({
         project: options?.project ?? this.options.project,
         content,
@@ -147,15 +189,156 @@ ${context}` : "",
       return { success: false, extracted: 0 };
     }
   }
+  /**
+   * Run a full agent turn with automatic memory read (before) + write (after).
+   */
+  async runTurn(params) {
+    const contextResult = await this.getContext(params.userMessage, {
+      userId: params.userId,
+      sessionId: params.sessionId,
+      project: params.project,
+      limit: params.limit
+    });
+    const prompt = contextResult.context ? `${contextResult.context}
+
+User: ${params.userMessage}` : params.userMessage;
+    const response = await params.generate(prompt);
+    const captureResult = await this.captureSession(
+      [
+        { role: "user", content: params.userMessage },
+        { role: "assistant", content: response }
+      ],
+      {
+        userId: params.userId,
+        sessionId: params.sessionId,
+        project: params.project
+      }
+    );
+    return {
+      response,
+      context: contextResult.context,
+      count: contextResult.count,
+      extracted: captureResult.extracted
+    };
+  }
   /**
    * Direct access to WhisperContext for advanced usage
    */
   raw() {
     return this.client;
   }
+  extractMemoryIdsFromBulkResponse(bulkResponse) {
+    const ids = [];
+    if (Array.isArray(bulkResponse?.memories)) {
+      for (const memory of bulkResponse.memories) {
+        if (memory?.id) ids.push(memory.id);
+      }
+    }
+    if (bulkResponse?.memory?.id) {
+      ids.push(bulkResponse.memory.id);
+    }
+    if (bulkResponse?.id) {
+      ids.push(bulkResponse.id);
+    }
+    return Array.from(new Set(ids));
+  }
 };
 var whisper_agent_default = Whisper;
 
+// ../src/sdk/middleware.ts
+var WhisperAgentMiddleware = class {
+  whisper;
+  promptBuilder;
+  constructor(config) {
+    this.whisper = new Whisper(config);
+    this.promptBuilder = config.promptBuilder || (({ context, userMessage }) => {
+      if (!context) return userMessage;
+      return `${context}
+
+User: ${userMessage}`;
+    });
+  }
+  async beforeTurn(params) {
+    const contextResult = await this.whisper.getContext(params.userMessage, {
+      userId: params.userId,
+      sessionId: params.sessionId,
+      project: params.project,
+      limit: params.contextLimit
+    });
+    const prompt = this.promptBuilder({
+      context: contextResult.context,
+      userMessage: params.userMessage
+    });
+    return {
+      prompt,
+      context: contextResult.context,
+      contextCount: contextResult.count
+    };
+  }
+  async afterTurn(params) {
+    return this.whisper.captureSession(
+      [
+        { role: "user", content: params.userMessage },
+        { role: "assistant", content: params.assistantMessage }
+      ],
+      {
+        userId: params.userId,
+        sessionId: params.sessionId,
+        project: params.project
+      }
+    );
+  }
+  async wrapGenerate(params) {
+    const before = await this.beforeTurn(params);
+    const response = await params.generate(before.prompt);
+    const after = await this.afterTurn({
+      userMessage: params.userMessage,
+      assistantMessage: response,
+      userId: params.userId,
+      sessionId: params.sessionId,
+      project: params.project
+    });
+    return {
+      response,
+      prompt: before.prompt,
+      context: before.context,
+      contextCount: before.contextCount,
+      extracted: after.extracted
+    };
+  }
+  raw() {
+    return this.whisper;
+  }
+};
+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;
@@ -186,11 +369,24 @@ function getBackoffDelay(attempt, base, max) {
 function isLikelyProjectId(projectRef) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(projectRef);
 }
+function normalizeBaseUrl(url) {
+  let normalized = url.trim().replace(/\/+$/, "");
+  normalized = normalized.replace(/\/api\/v1$/i, "");
+  normalized = normalized.replace(/\/v1$/i, "");
+  normalized = normalized.replace(/\/api$/i, "");
+  return normalized;
+}
+function normalizeEndpoint(endpoint) {
+  const withLeadingSlash = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  if (/^\/api\/v1(\/|$)/i.test(withLeadingSlash)) {
+    return withLeadingSlash.replace(/^\/api/i, "");
+  }
+  return withLeadingSlash;
+}
 var WhisperContext = class _WhisperContext {
   apiKey;
   baseUrl;
   defaultProject;
-  orgId;
   timeoutMs;
   retryConfig;
   projectRefToId = /* @__PURE__ */ new Map();
@@ -204,9 +400,8 @@ var WhisperContext = class _WhisperContext {
       });
     }
     this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || "https://context.usewhisper.dev";
+    this.baseUrl = normalizeBaseUrl(config.baseUrl || "https://context.usewhisper.dev");
     this.defaultProject = config.project;
-    this.orgId = config.orgId;
     this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.retryConfig = {
       maxAttempts: config.retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
@@ -219,7 +414,6 @@ var WhisperContext = class _WhisperContext {
       apiKey: this.apiKey,
       baseUrl: this.baseUrl,
       project,
-      orgId: this.orgId,
       timeoutMs: this.timeoutMs,
       retry: this.retryConfig
     });
@@ -336,20 +530,28 @@ var WhisperContext = class _WhisperContext {
   }
   async request(endpoint, options = {}) {
     const maxAttempts = Math.max(1, this.retryConfig.maxAttempts);
+    const normalizedEndpoint = normalizeEndpoint(endpoint);
     let lastError;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
       try {
-        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        const headers = {
+          "Content-Type": "application/json",
+          ...options.headers
+        };
+        const hasAuthHeader = Object.keys(headers).some((k) => k.toLowerCase() === "authorization");
+        const hasApiKeyHeader = Object.keys(headers).some((k) => k.toLowerCase() === "x-api-key");
+        if (!hasAuthHeader) {
+          headers.Authorization = `Bearer ${this.apiKey}`;
+        }
+        if (!hasApiKeyHeader) {
+          headers["X-API-Key"] = this.apiKey;
+        }
+        const response = await fetch(`${this.baseUrl}${normalizedEndpoint}`, {
           ...options,
           signal: controller.signal,
-          headers: {
-            Authorization: `Bearer ${this.apiKey}`,
-            "Content-Type": "application/json",
-            ...this.orgId ? { "X-Whisper-Org-Id": this.orgId } : {},
-            ...options.headers
-          }
+          headers
         });
         clearTimeout(timeout);
         if (!response.ok) {
@@ -538,6 +740,34 @@ var WhisperContext = class _WhisperContext {
       return { id, success: true, path: "legacy", fallback_used: true };
     });
   }
+  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 })
+    }));
+  }
+  async extractMemories(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/extract", {
+      method: "POST",
+      body: JSON.stringify({ ...params, project })
+    }));
+  }
+  async extractSessionMemories(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/extract/session", {
+      method: "POST",
+      body: JSON.stringify({
+        ...params,
+        project,
+        messages: params.messages.map((m) => ({
+          ...m,
+          timestamp: m.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        }))
+      })
+    }));
+  }
   async searchMemories(params) {
     const projectRef = this.getRequiredProject(params.project);
     return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/memory/search", {
@@ -610,6 +840,26 @@ var WhisperContext = class _WhisperContext {
   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", {
@@ -734,6 +984,9 @@ var WhisperContext = class _WhisperContext {
   };
   memory = {
     add: (params) => this.addMemory(params),
+    addBulk: (params) => this.addMemoriesBulk(params),
+    extract: (params) => this.extractMemories(params),
+    extractSession: (params) => this.extractSessionMemories(params),
     search: (params) => this.searchMemories(params),
     searchSOTA: (params) => this.searchMemoriesSOTA(params),
     ingestSession: (params) => this.ingestSession(params),
@@ -743,6 +996,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)
@@ -772,8 +1027,11 @@ var WhisperContext = class _WhisperContext {
 var index_default = WhisperContext;
 export {
   Whisper,
+  WhisperAgentMiddleware,
   WhisperContext,
   whisper_agent_default as WhisperDefault,
   WhisperError,
-  index_default as default
+  createAgentMiddleware,
+  index_default as default,
+  memoryGraphToMermaid
 };

package/package.json

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