@usewhisper/sdk 2.0.0 → 2.1.0

package/README.md

@@ -14,7 +14,7 @@ npm install @usewhisper/sdk
 import { WhisperContext } from '@usewhisper/sdk';
 
 const whisper = new WhisperContext({ 
-  apiKey: 'wctx_your_api_key_here'
+  apiKey: 'wsk_your_api_key_here'
 });
 
 // Create a project
@@ -48,7 +48,7 @@ Get your API key from the [Whisper dashboard](https://usewhisper.dev/dashboard):
 
 ```typescript
 const whisper = new WhisperContext({
-  apiKey: 'wctx_...',  // Your API key
+  apiKey: 'wsk_...',  // Your API key
   baseUrl: 'https://context.usewhisper.dev'  // Optional, defaults to production
 });
 ```

package/index.d.mts

@@ -24,12 +24,33 @@ interface WhisperOptions extends WhisperConfig {
      * Default: "Relevant context:"
      */
     contextPrefix?: string;
+    /**
+     * Extract structured memories before writing.
+     * Default: true
+     */
+    autoExtract?: boolean;
+    /**
+     * Minimum extraction confidence for auto-write.
+     * Default: 0.65
+     */
+    autoExtractMinConfidence?: number;
+    /**
+     * Maximum extracted memories to write per remember/capture call.
+     * Default: 5
+     */
+    maxMemoriesPerCapture?: number;
 }
 interface ContextResult {
     context: string;
     results: QueryResult["results"];
     count: number;
 }
+interface RememberResult {
+    success: boolean;
+    memoryId?: string;
+    memoryIds?: string[];
+    extracted?: number;
+}
 /**
  * Simple, transparent memory layer
  *
@@ -114,10 +135,7 @@ declare class Whisper {
         userId?: string;
         sessionId?: string;
         project?: string;
-    }): Promise<{
-        success: boolean;
-        memoryId?: string;
-    }>;
+    }): Promise<RememberResult>;
     /**
      * Alias for remember() - same thing
      */
@@ -125,10 +143,7 @@ declare class Whisper {
         userId?: string;
         sessionId?: string;
         project?: string;
-    }): Promise<{
-        success: boolean;
-        memoryId?: string;
-    }>;
+    }): Promise<RememberResult>;
     /**
      * Capture from multiple messages (e.g., full conversation)
      */
@@ -143,11 +158,86 @@ declare class Whisper {
         success: boolean;
         extracted: number;
     }>;
+    /**
+     * Run a full agent turn with automatic memory read (before) + write (after).
+     */
+    runTurn(params: {
+        userMessage: string;
+        generate: (prompt: string) => Promise<string>;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        limit?: number;
+    }): Promise<{
+        response: string;
+        context: string;
+        count: number;
+        extracted: number;
+    }>;
     /**
      * Direct access to WhisperContext for advanced usage
      */
     raw(): WhisperContext;
+    private extractMemoryIdsFromBulkResponse;
+}
+
+interface AgentMiddlewareConfig extends WhisperOptions {
+    /**
+     * Build the prompt passed to the model.
+     */
+    promptBuilder?: (params: {
+        context: string;
+        userMessage: string;
+    }) => string;
+}
+interface AgentTurnParams {
+    userMessage: string;
+    userId?: string;
+    sessionId?: string;
+    project?: string;
+    contextLimit?: number;
+}
+interface AgentTurnResult {
+    prompt: string;
+    context: string;
+    contextCount: number;
 }
+interface WrappedGenerateResult {
+    response: string;
+    prompt: string;
+    context: string;
+    contextCount: number;
+    extracted: number;
+}
+/**
+ * Drop-in middleware for existing AI agents.
+ *
+ * Typical flow:
+ * 1) beforeTurn -> retrieve context
+ * 2) call your model
+ * 3) afterTurn -> store memories
+ */
+declare class WhisperAgentMiddleware {
+    private readonly whisper;
+    private readonly promptBuilder;
+    constructor(config: AgentMiddlewareConfig);
+    beforeTurn(params: AgentTurnParams): Promise<AgentTurnResult>;
+    afterTurn(params: {
+        userMessage: string;
+        assistantMessage: string;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+    }): Promise<{
+        success: boolean;
+        extracted: number;
+    }>;
+    wrapGenerate(params: AgentTurnParams & {
+        generate: (prompt: string) => Promise<string>;
+    }): Promise<WrappedGenerateResult>;
+    raw(): Whisper;
+}
+declare function createAgentMiddleware(config: AgentMiddlewareConfig): WhisperAgentMiddleware;
 
 /**
  * Whisper Context SDK
@@ -157,7 +247,6 @@ interface WhisperConfig {
     apiKey: string;
     baseUrl?: string;
     project?: string;
-    orgId?: string;
     timeoutMs?: number;
     retry?: {
         maxAttempts?: number;
@@ -246,6 +335,23 @@ interface Memory {
     createdAt: string;
     updatedAt: string;
 }
+type MemoryKind = "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+interface ExtractedMemory {
+    content: string;
+    memoryType: MemoryKind;
+    entityMentions: string[];
+    eventDate: string | null;
+    confidence: number;
+    reasoning?: string;
+    inferred?: boolean;
+}
+interface MemoryExtractionResult {
+    explicit: ExtractedMemory[];
+    implicit: ExtractedMemory[];
+    all: ExtractedMemory[];
+    extractionMethod: "pattern" | "inference" | "hybrid" | "skipped";
+    latencyMs: number;
+}
 type WhisperErrorCode = "INVALID_API_KEY" | "PROJECT_NOT_FOUND" | "PROJECT_AMBIGUOUS" | "RATE_LIMITED" | "TEMPORARY_UNAVAILABLE" | "NETWORK_ERROR" | "TIMEOUT" | "REQUEST_FAILED" | "MISSING_PROJECT";
 declare class WhisperError extends Error {
     code: WhisperErrorCode;
@@ -264,7 +370,6 @@ declare class WhisperContext {
     private apiKey;
     private baseUrl;
     private defaultProject?;
-    private orgId?;
     private timeoutMs;
     private retryConfig;
     private projectRefToId;
@@ -335,6 +440,51 @@ declare class WhisperContext {
         path: "sota" | "legacy";
         fallback_used: boolean;
     }>;
+    addMemoriesBulk(params: {
+        project?: string;
+        memories: Array<{
+            content: string;
+            memory_type?: MemoryKind | "episodic" | "semantic" | "procedural";
+            user_id?: string;
+            session_id?: string;
+            agent_id?: string;
+            importance?: number;
+            confidence?: number;
+            metadata?: Record<string, any>;
+            entity_mentions?: string[];
+            document_date?: string;
+            event_date?: string;
+        }>;
+        namespace?: string;
+        tags?: string[];
+        async?: boolean;
+        webhook_url?: string;
+    }): Promise<any>;
+    extractMemories(params: {
+        project?: string;
+        message: string;
+        context?: string;
+        session_id?: string;
+        user_id?: string;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+        min_confidence?: number;
+    }): Promise<MemoryExtractionResult>;
+    extractSessionMemories(params: {
+        project?: string;
+        user_id?: string;
+        messages: Array<{
+            role: "user" | "assistant" | "system";
+            content: string;
+            timestamp?: string;
+        }>;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+    }): Promise<{
+        memories: ExtractedMemory[];
+        count: number;
+        latencyMs: number;
+    }>;
     searchMemories(params: {
         project?: string;
         query: string;
@@ -641,6 +791,13 @@ declare class WhisperContext {
             path: "sota" | "legacy";
             fallback_used: boolean;
         }>;
+        addBulk: (params: Parameters<WhisperContext["addMemoriesBulk"]>[0]) => Promise<any>;
+        extract: (params: Parameters<WhisperContext["extractMemories"]>[0]) => Promise<MemoryExtractionResult>;
+        extractSession: (params: Parameters<WhisperContext["extractSessionMemories"]>[0]) => Promise<{
+            memories: ExtractedMemory[];
+            count: number;
+            latencyMs: number;
+        }>;
         search: (params: Parameters<WhisperContext["searchMemories"]>[0]) => Promise<any>;
         searchSOTA: (params: Parameters<WhisperContext["searchMemoriesSOTA"]>[0]) => Promise<any>;
         ingestSession: (params: Parameters<WhisperContext["ingestSession"]>[0]) => Promise<{
@@ -762,4 +919,4 @@ declare class WhisperContext {
     };
 }
 
-export { type Memory, type Project, type QueryParams, type QueryResult, type Source, Whisper, type WhisperConfig, WhisperContext, Whisper as WhisperDefault, WhisperError, type WhisperErrorCode, WhisperContext as default };
+export { type ExtractedMemory, type Memory, type MemoryExtractionResult, type MemoryKind, type Project, type QueryParams, type QueryResult, type Source, Whisper, WhisperAgentMiddleware, type WhisperConfig, WhisperContext, Whisper as WhisperDefault, WhisperError, type WhisperErrorCode, createAgentMiddleware, WhisperContext as default };

package/index.d.ts

@@ -24,12 +24,33 @@ interface WhisperOptions extends WhisperConfig {
      * Default: "Relevant context:"
      */
     contextPrefix?: string;
+    /**
+     * Extract structured memories before writing.
+     * Default: true
+     */
+    autoExtract?: boolean;
+    /**
+     * Minimum extraction confidence for auto-write.
+     * Default: 0.65
+     */
+    autoExtractMinConfidence?: number;
+    /**
+     * Maximum extracted memories to write per remember/capture call.
+     * Default: 5
+     */
+    maxMemoriesPerCapture?: number;
 }
 interface ContextResult {
     context: string;
     results: QueryResult["results"];
     count: number;
 }
+interface RememberResult {
+    success: boolean;
+    memoryId?: string;
+    memoryIds?: string[];
+    extracted?: number;
+}
 /**
  * Simple, transparent memory layer
  *
@@ -114,10 +135,7 @@ declare class Whisper {
         userId?: string;
         sessionId?: string;
         project?: string;
-    }): Promise<{
-        success: boolean;
-        memoryId?: string;
-    }>;
+    }): Promise<RememberResult>;
     /**
      * Alias for remember() - same thing
      */
@@ -125,10 +143,7 @@ declare class Whisper {
         userId?: string;
         sessionId?: string;
         project?: string;
-    }): Promise<{
-        success: boolean;
-        memoryId?: string;
-    }>;
+    }): Promise<RememberResult>;
     /**
      * Capture from multiple messages (e.g., full conversation)
      */
@@ -143,11 +158,86 @@ declare class Whisper {
         success: boolean;
         extracted: number;
     }>;
+    /**
+     * Run a full agent turn with automatic memory read (before) + write (after).
+     */
+    runTurn(params: {
+        userMessage: string;
+        generate: (prompt: string) => Promise<string>;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        limit?: number;
+    }): Promise<{
+        response: string;
+        context: string;
+        count: number;
+        extracted: number;
+    }>;
     /**
      * Direct access to WhisperContext for advanced usage
      */
     raw(): WhisperContext;
+    private extractMemoryIdsFromBulkResponse;
+}
+
+interface AgentMiddlewareConfig extends WhisperOptions {
+    /**
+     * Build the prompt passed to the model.
+     */
+    promptBuilder?: (params: {
+        context: string;
+        userMessage: string;
+    }) => string;
+}
+interface AgentTurnParams {
+    userMessage: string;
+    userId?: string;
+    sessionId?: string;
+    project?: string;
+    contextLimit?: number;
+}
+interface AgentTurnResult {
+    prompt: string;
+    context: string;
+    contextCount: number;
 }
+interface WrappedGenerateResult {
+    response: string;
+    prompt: string;
+    context: string;
+    contextCount: number;
+    extracted: number;
+}
+/**
+ * Drop-in middleware for existing AI agents.
+ *
+ * Typical flow:
+ * 1) beforeTurn -> retrieve context
+ * 2) call your model
+ * 3) afterTurn -> store memories
+ */
+declare class WhisperAgentMiddleware {
+    private readonly whisper;
+    private readonly promptBuilder;
+    constructor(config: AgentMiddlewareConfig);
+    beforeTurn(params: AgentTurnParams): Promise<AgentTurnResult>;
+    afterTurn(params: {
+        userMessage: string;
+        assistantMessage: string;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+    }): Promise<{
+        success: boolean;
+        extracted: number;
+    }>;
+    wrapGenerate(params: AgentTurnParams & {
+        generate: (prompt: string) => Promise<string>;
+    }): Promise<WrappedGenerateResult>;
+    raw(): Whisper;
+}
+declare function createAgentMiddleware(config: AgentMiddlewareConfig): WhisperAgentMiddleware;
 
 /**
  * Whisper Context SDK
@@ -157,7 +247,6 @@ interface WhisperConfig {
     apiKey: string;
     baseUrl?: string;
     project?: string;
-    orgId?: string;
     timeoutMs?: number;
     retry?: {
         maxAttempts?: number;
@@ -246,6 +335,23 @@ interface Memory {
     createdAt: string;
     updatedAt: string;
 }
+type MemoryKind = "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+interface ExtractedMemory {
+    content: string;
+    memoryType: MemoryKind;
+    entityMentions: string[];
+    eventDate: string | null;
+    confidence: number;
+    reasoning?: string;
+    inferred?: boolean;
+}
+interface MemoryExtractionResult {
+    explicit: ExtractedMemory[];
+    implicit: ExtractedMemory[];
+    all: ExtractedMemory[];
+    extractionMethod: "pattern" | "inference" | "hybrid" | "skipped";
+    latencyMs: number;
+}
 type WhisperErrorCode = "INVALID_API_KEY" | "PROJECT_NOT_FOUND" | "PROJECT_AMBIGUOUS" | "RATE_LIMITED" | "TEMPORARY_UNAVAILABLE" | "NETWORK_ERROR" | "TIMEOUT" | "REQUEST_FAILED" | "MISSING_PROJECT";
 declare class WhisperError extends Error {
     code: WhisperErrorCode;
@@ -264,7 +370,6 @@ declare class WhisperContext {
     private apiKey;
     private baseUrl;
     private defaultProject?;
-    private orgId?;
     private timeoutMs;
     private retryConfig;
     private projectRefToId;
@@ -335,6 +440,51 @@ declare class WhisperContext {
         path: "sota" | "legacy";
         fallback_used: boolean;
     }>;
+    addMemoriesBulk(params: {
+        project?: string;
+        memories: Array<{
+            content: string;
+            memory_type?: MemoryKind | "episodic" | "semantic" | "procedural";
+            user_id?: string;
+            session_id?: string;
+            agent_id?: string;
+            importance?: number;
+            confidence?: number;
+            metadata?: Record<string, any>;
+            entity_mentions?: string[];
+            document_date?: string;
+            event_date?: string;
+        }>;
+        namespace?: string;
+        tags?: string[];
+        async?: boolean;
+        webhook_url?: string;
+    }): Promise<any>;
+    extractMemories(params: {
+        project?: string;
+        message: string;
+        context?: string;
+        session_id?: string;
+        user_id?: string;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+        min_confidence?: number;
+    }): Promise<MemoryExtractionResult>;
+    extractSessionMemories(params: {
+        project?: string;
+        user_id?: string;
+        messages: Array<{
+            role: "user" | "assistant" | "system";
+            content: string;
+            timestamp?: string;
+        }>;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+    }): Promise<{
+        memories: ExtractedMemory[];
+        count: number;
+        latencyMs: number;
+    }>;
     searchMemories(params: {
         project?: string;
         query: string;
@@ -641,6 +791,13 @@ declare class WhisperContext {
             path: "sota" | "legacy";
             fallback_used: boolean;
         }>;
+        addBulk: (params: Parameters<WhisperContext["addMemoriesBulk"]>[0]) => Promise<any>;
+        extract: (params: Parameters<WhisperContext["extractMemories"]>[0]) => Promise<MemoryExtractionResult>;
+        extractSession: (params: Parameters<WhisperContext["extractSessionMemories"]>[0]) => Promise<{
+            memories: ExtractedMemory[];
+            count: number;
+            latencyMs: number;
+        }>;
         search: (params: Parameters<WhisperContext["searchMemories"]>[0]) => Promise<any>;
         searchSOTA: (params: Parameters<WhisperContext["searchMemoriesSOTA"]>[0]) => Promise<any>;
         ingestSession: (params: Parameters<WhisperContext["ingestSession"]>[0]) => Promise<{
@@ -762,4 +919,4 @@ declare class WhisperContext {
     };
 }
 
-export { type Memory, type Project, type QueryParams, type QueryResult, type Source, Whisper, type WhisperConfig, WhisperContext, Whisper as WhisperDefault, WhisperError, type WhisperErrorCode, WhisperContext as default };
+export { type ExtractedMemory, type Memory, type MemoryExtractionResult, type MemoryKind, type Project, type QueryParams, type QueryResult, type Source, Whisper, WhisperAgentMiddleware, type WhisperConfig, WhisperContext, Whisper as WhisperDefault, WhisperError, type WhisperErrorCode, createAgentMiddleware, WhisperContext as default };

package/index.js

@@ -21,9 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Whisper: () => Whisper,
+  WhisperAgentMiddleware: () => WhisperAgentMiddleware,
   WhisperContext: () => WhisperContext,
   WhisperDefault: () => whisper_agent_default,
   WhisperError: () => WhisperError,
+  createAgentMiddleware: () => createAgentMiddleware,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
@@ -43,7 +45,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);
@@ -52,12 +53,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
     };
   }
   /**
@@ -132,6 +135,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,
@@ -177,15 +221,131 @@ ${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/index.ts
 var WhisperError = class extends Error {
   code;
@@ -216,11 +376,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();
@@ -234,9 +407,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,
@@ -249,7 +421,6 @@ var WhisperContext = class _WhisperContext {
       apiKey: this.apiKey,
       baseUrl: this.baseUrl,
       project,
-      orgId: this.orgId,
       timeoutMs: this.timeoutMs,
       retry: this.retryConfig
     });
@@ -366,20 +537,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) {
@@ -568,6 +747,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", {
@@ -764,6 +971,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),
@@ -803,7 +1013,9 @@ var index_default = WhisperContext;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Whisper,
+  WhisperAgentMiddleware,
   WhisperContext,
   WhisperDefault,
-  WhisperError
+  WhisperError,
+  createAgentMiddleware
 });

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,131 @@ ${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/index.ts
 var WhisperError = class extends Error {
   code;
@@ -186,11 +344,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 +375,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 +389,6 @@ var WhisperContext = class _WhisperContext {
       apiKey: this.apiKey,
       baseUrl: this.baseUrl,
       project,
-      orgId: this.orgId,
       timeoutMs: this.timeoutMs,
       retry: this.retryConfig
     });
@@ -336,20 +505,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 +715,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", {
@@ -734,6 +939,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),
@@ -772,8 +980,10 @@ var WhisperContext = class _WhisperContext {
 var index_default = WhisperContext;
 export {
   Whisper,
+  WhisperAgentMiddleware,
   WhisperContext,
   whisper_agent_default as WhisperDefault,
   WhisperError,
+  createAgentMiddleware,
   index_default as default
 };

package/package.json

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