@usewhisper/sdk 2.2.0 → 3.0.0

package/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,23 +17,410 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../src/sdk/index.ts
 var index_exports = {};
 __export(index_exports, {
+  LangChainMemoryAdapter: () => LangChainMemoryAdapter,
+  LangGraphCheckpointAdapter: () => LangGraphCheckpointAdapter,
   Whisper: () => Whisper,
   WhisperAgentMiddleware: () => WhisperAgentMiddleware,
+  WhisperClient: () => WhisperClient,
   WhisperContext: () => WhisperContext,
   WhisperDefault: () => whisper_agent_default,
   WhisperError: () => WhisperError,
+  WhisperRuntimeClient: () => whisper_default,
   createAgentMiddleware: () => createAgentMiddleware,
+  createLangChainMemoryAdapter: () => createLangChainMemoryAdapter,
+  createLangGraphCheckpointAdapter: () => createLangGraphCheckpointAdapter,
   default: () => index_default,
   memoryGraphToMermaid: () => memoryGraphToMermaid
 });
 module.exports = __toCommonJS(index_exports);
 
+// ../src/sdk/core/telemetry.ts
+var DiagnosticsStore = class {
+  maxEntries;
+  records = [];
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(maxEntries = 1e3) {
+    this.maxEntries = Math.max(1, maxEntries);
+  }
+  add(record) {
+    this.records.push(record);
+    if (this.records.length > this.maxEntries) {
+      this.records.splice(0, this.records.length - this.maxEntries);
+    }
+    for (const fn of this.subscribers) {
+      try {
+        fn(record);
+      } catch {
+      }
+    }
+  }
+  getLast(limit = 25) {
+    const count = Math.max(1, limit);
+    return this.records.slice(-count);
+  }
+  snapshot() {
+    const total = this.records.length;
+    const success = this.records.filter((r) => r.success).length;
+    const failure = total - success;
+    const duration = this.records.reduce((acc, item) => acc + item.durationMs, 0);
+    return {
+      total,
+      success,
+      failure,
+      avgDurationMs: total > 0 ? duration / total : 0,
+      lastTraceId: this.records[this.records.length - 1]?.traceId
+    };
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => {
+      this.subscribers.delete(fn);
+    };
+  }
+};
+
+// ../src/sdk/core/utils.ts
+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;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function stableHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function normalizeQuery(query) {
+  return query.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function randomId(prefix = "id") {
+  return `${prefix}_${stableHash(`${Date.now()}_${Math.random()}`)}`;
+}
+
+// ../src/sdk/core/client.ts
+var DEFAULT_TIMEOUTS = {
+  searchMs: 3e3,
+  writeAckMs: 2e3,
+  bulkMs: 1e4,
+  profileMs: 2500,
+  sessionMs: 2500
+};
+var DEFAULT_RETRYABLE_STATUS = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRY_ATTEMPTS = {
+  search: 3,
+  writeAck: 2,
+  bulk: 2,
+  profile: 2,
+  session: 2,
+  query: 3,
+  get: 2
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function toMessage(payload, status, statusText) {
+  if (typeof payload === "string" && payload.trim()) return payload;
+  if (isObject(payload)) {
+    const maybeError = payload.error;
+    const maybeMessage = payload.message;
+    if (typeof maybeError === "string" && maybeError.trim()) return maybeError;
+    if (typeof maybeMessage === "string" && maybeMessage.trim()) return maybeMessage;
+    if (isObject(maybeError) && typeof maybeError.message === "string") return maybeError.message;
+  }
+  return `HTTP ${status}: ${statusText}`;
+}
+var RuntimeClientError = class extends Error {
+  status;
+  retryable;
+  code;
+  details;
+  traceId;
+  constructor(args) {
+    super(args.message);
+    this.name = "RuntimeClientError";
+    this.status = args.status;
+    this.retryable = args.retryable;
+    this.code = args.code;
+    this.details = args.details;
+    this.traceId = args.traceId;
+  }
+};
+var RuntimeClient = class {
+  apiKey;
+  baseUrl;
+  sdkVersion;
+  compatMode;
+  retryPolicy;
+  timeouts;
+  diagnostics;
+  inFlight = /* @__PURE__ */ new Map();
+  constructor(options, diagnostics) {
+    if (!options.apiKey) {
+      throw new RuntimeClientError({
+        code: "INVALID_API_KEY",
+        message: "API key is required",
+        retryable: false
+      });
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl || "https://context.usewhisper.dev");
+    this.sdkVersion = options.sdkVersion || "2.x-runtime";
+    this.compatMode = options.compatMode || "fallback";
+    this.retryPolicy = {
+      retryableStatusCodes: options.retryPolicy?.retryableStatusCodes || DEFAULT_RETRYABLE_STATUS,
+      retryOnNetworkError: options.retryPolicy?.retryOnNetworkError ?? true,
+      maxBackoffMs: options.retryPolicy?.maxBackoffMs ?? 1200,
+      baseBackoffMs: options.retryPolicy?.baseBackoffMs ?? 250,
+      maxAttemptsByOperation: options.retryPolicy?.maxAttemptsByOperation || {}
+    };
+    this.timeouts = {
+      ...DEFAULT_TIMEOUTS,
+      ...options.timeouts || {}
+    };
+    this.diagnostics = diagnostics || new DiagnosticsStore(1e3);
+  }
+  getDiagnosticsStore() {
+    return this.diagnostics;
+  }
+  getCompatMode() {
+    return this.compatMode;
+  }
+  timeoutFor(operation) {
+    switch (operation) {
+      case "search":
+        return this.timeouts.searchMs;
+      case "writeAck":
+        return this.timeouts.writeAckMs;
+      case "bulk":
+        return this.timeouts.bulkMs;
+      case "profile":
+        return this.timeouts.profileMs;
+      case "session":
+        return this.timeouts.sessionMs;
+      case "query":
+      case "get":
+      default:
+        return this.timeouts.searchMs;
+    }
+  }
+  maxAttemptsFor(operation) {
+    const override = this.retryPolicy.maxAttemptsByOperation?.[operation];
+    return Math.max(1, override ?? DEFAULT_RETRY_ATTEMPTS[operation]);
+  }
+  shouldRetryStatus(status) {
+    return status !== void 0 && this.retryPolicy.retryableStatusCodes?.includes(status) === true;
+  }
+  backoff(attempt) {
+    const base = this.retryPolicy.baseBackoffMs ?? 250;
+    const max = this.retryPolicy.maxBackoffMs ?? 1200;
+    const jitter = 0.8 + Math.random() * 0.4;
+    return Math.min(max, Math.floor(base * Math.pow(2, attempt) * jitter));
+  }
+  runtimeName() {
+    const maybeWindow = globalThis.window;
+    return maybeWindow && typeof maybeWindow === "object" ? "browser" : "node";
+  }
+  createRequestFingerprint(options) {
+    const normalizedEndpoint = normalizeEndpoint(options.endpoint);
+    const authFingerprint = stableHash(this.apiKey.replace(/^Bearer\s+/i, ""));
+    const payload = JSON.stringify({
+      method: options.method || "GET",
+      endpoint: normalizedEndpoint,
+      body: options.body || null,
+      extra: options.dedupeKeyExtra || "",
+      authFingerprint
+    });
+    return stableHash(payload);
+  }
+  async request(options) {
+    const dedupeKey = options.idempotent ? this.createRequestFingerprint(options) : null;
+    if (dedupeKey) {
+      const inFlight = this.inFlight.get(dedupeKey);
+      if (inFlight) {
+        const data = await inFlight;
+        this.diagnostics.add({
+          id: randomId("diag"),
+          startedAt: nowIso(),
+          endedAt: nowIso(),
+          traceId: data.traceId,
+          spanId: randomId("span"),
+          operation: options.operation,
+          method: options.method || "GET",
+          endpoint: normalizeEndpoint(options.endpoint),
+          status: data.status,
+          durationMs: 0,
+          success: true,
+          deduped: true
+        });
+        const cloned = {
+          data: data.data,
+          status: data.status,
+          traceId: data.traceId
+        };
+        return cloned;
+      }
+    }
+    const runner = this.performRequest(options).then((data) => {
+      if (dedupeKey) this.inFlight.delete(dedupeKey);
+      return data;
+    }).catch((error) => {
+      if (dedupeKey) this.inFlight.delete(dedupeKey);
+      throw error;
+    });
+    if (dedupeKey) {
+      this.inFlight.set(dedupeKey, runner);
+    }
+    return runner;
+  }
+  async performRequest(options) {
+    const method = options.method || "GET";
+    const normalizedEndpoint = normalizeEndpoint(options.endpoint);
+    const operation = options.operation;
+    const maxAttempts = this.maxAttemptsFor(operation);
+    const timeoutMs = this.timeoutFor(operation);
+    const traceId = options.traceId || randomId("trace");
+    let lastError = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      const spanId = randomId("span");
+      const startedAt = Date.now();
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetch(`${this.baseUrl}${normalizedEndpoint}`, {
+          method,
+          signal: controller.signal,
+          keepalive: method !== "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`,
+            "X-API-Key": this.apiKey.replace(/^Bearer\s+/i, ""),
+            "x-trace-id": traceId,
+            "x-span-id": spanId,
+            "x-sdk-version": this.sdkVersion,
+            "x-sdk-runtime": this.runtimeName(),
+            ...options.headers || {}
+          },
+          body: method === "GET" || method === "DELETE" ? void 0 : JSON.stringify(options.body || {})
+        });
+        clearTimeout(timeout);
+        let payload = null;
+        try {
+          payload = await response.json();
+        } catch {
+          payload = await response.text().catch(() => "");
+        }
+        const durationMs = Date.now() - startedAt;
+        const record = {
+          id: randomId("diag"),
+          startedAt: new Date(startedAt).toISOString(),
+          endedAt: nowIso(),
+          traceId,
+          spanId,
+          operation,
+          method,
+          endpoint: normalizedEndpoint,
+          status: response.status,
+          durationMs,
+          success: response.ok
+        };
+        this.diagnostics.add(record);
+        if (response.ok) {
+          return {
+            data: payload,
+            status: response.status,
+            traceId
+          };
+        }
+        const message = toMessage(payload, response.status, response.statusText);
+        const retryable = this.shouldRetryStatus(response.status);
+        const error = new RuntimeClientError({
+          message,
+          status: response.status,
+          retryable,
+          code: response.status === 404 ? "NOT_FOUND" : "REQUEST_FAILED",
+          details: payload,
+          traceId
+        });
+        lastError = error;
+        if (!retryable || attempt === maxAttempts - 1) {
+          throw error;
+        }
+      } catch (error) {
+        clearTimeout(timeout);
+        const durationMs = Date.now() - startedAt;
+        const isAbort = isObject(error) && error.name === "AbortError";
+        const mapped = error instanceof RuntimeClientError ? error : new RuntimeClientError({
+          message: isAbort ? "Request timed out" : error instanceof Error ? error.message : "Network error",
+          retryable: this.retryPolicy.retryOnNetworkError ?? true,
+          code: isAbort ? "TIMEOUT" : "NETWORK_ERROR",
+          traceId
+        });
+        lastError = mapped;
+        this.diagnostics.add({
+          id: randomId("diag"),
+          startedAt: new Date(startedAt).toISOString(),
+          endedAt: nowIso(),
+          traceId,
+          spanId,
+          operation,
+          method,
+          endpoint: normalizedEndpoint,
+          durationMs,
+          success: false,
+          errorCode: mapped.code,
+          errorMessage: mapped.message
+        });
+        if (!mapped.retryable || attempt === maxAttempts - 1) {
+          throw mapped;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.backoff(attempt)));
+    }
+    throw lastError || new RuntimeClientError({
+      message: "Request failed",
+      retryable: false,
+      code: "REQUEST_FAILED"
+    });
+  }
+};
+
 // ../src/sdk/whisper-agent.ts
+var DEPRECATION_WARNINGS = /* @__PURE__ */ new Set();
+function warnDeprecatedOnce(key, message) {
+  if (DEPRECATION_WARNINGS.has(key)) return;
+  DEPRECATION_WARNINGS.add(key);
+  if (typeof console !== "undefined" && typeof console.warn === "function") {
+    console.warn(message);
+  }
+}
 var Whisper = class {
   client;
   options;
@@ -49,6 +438,10 @@ var Whisper = class {
     if (options.timeoutMs) clientConfig.timeoutMs = options.timeoutMs;
     if (options.retry) clientConfig.retry = options.retry;
     this.client = new WhisperContext(clientConfig);
+    warnDeprecatedOnce(
+      "whisper_agent_wrapper",
+      "[Whisper SDK] Whisper wrapper is supported for v2 compatibility. Prefer WhisperClient for new integrations."
+    );
     const finalRetry = options.retry || { maxAttempts: 3, baseDelayMs: 250, maxDelayMs: 2e3 };
     this.options = {
       apiKey: options.apiKey,
@@ -150,7 +543,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,
@@ -218,6 +611,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 };
     }
@@ -270,13 +667,1092 @@ User: ${params.userMessage}` : params.userMessage;
     if (bulkResponse?.memory?.id) {
       ids.push(bulkResponse.memory.id);
     }
-    if (bulkResponse?.id) {
-      ids.push(bulkResponse.id);
+    if (bulkResponse?.id) {
+      ids.push(bulkResponse.id);
+    }
+    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;
+
+// ../src/sdk/core/cache.ts
+var SearchResponseCache = class {
+  ttlMs;
+  capacity;
+  byKey = /* @__PURE__ */ new Map();
+  scopeIndex = /* @__PURE__ */ new Map();
+  constructor(ttlMs = 7e3, capacity = 500) {
+    this.ttlMs = Math.max(1e3, ttlMs);
+    this.capacity = Math.max(10, capacity);
+  }
+  makeScopeKey(project, userId, sessionId) {
+    return `${project}:${userId || "_"}:${sessionId || "_"}`;
+  }
+  makeKey(input) {
+    const normalized = {
+      project: input.project,
+      userId: input.userId || "",
+      sessionId: input.sessionId || "",
+      query: normalizeQuery(input.query),
+      topK: input.topK,
+      profile: input.profile,
+      includePending: input.includePending
+    };
+    return `search:${stableHash(JSON.stringify(normalized))}`;
+  }
+  get(key) {
+    const found = this.byKey.get(key);
+    if (!found) return null;
+    if (found.expiresAt <= Date.now()) {
+      this.deleteByKey(key);
+      return null;
+    }
+    found.touchedAt = Date.now();
+    return found.value;
+  }
+  set(key, scopeKey, value) {
+    this.byKey.set(key, {
+      value,
+      scopeKey,
+      touchedAt: Date.now(),
+      expiresAt: Date.now() + this.ttlMs
+    });
+    if (!this.scopeIndex.has(scopeKey)) {
+      this.scopeIndex.set(scopeKey, /* @__PURE__ */ new Set());
+    }
+    this.scopeIndex.get(scopeKey).add(key);
+    this.evictIfNeeded();
+  }
+  invalidateScope(scopeKey) {
+    const keys = this.scopeIndex.get(scopeKey);
+    if (!keys || keys.size === 0) {
+      return 0;
+    }
+    const toDelete = Array.from(keys);
+    for (const key of toDelete) {
+      this.deleteByKey(key);
+    }
+    this.scopeIndex.delete(scopeKey);
+    return toDelete.length;
+  }
+  evictIfNeeded() {
+    if (this.byKey.size <= this.capacity) return;
+    const ordered = Array.from(this.byKey.entries()).sort((a, b) => a[1].touchedAt - b[1].touchedAt);
+    const removeCount = this.byKey.size - this.capacity;
+    for (let i = 0; i < removeCount; i += 1) {
+      this.deleteByKey(ordered[i][0]);
+    }
+  }
+  deleteByKey(key) {
+    const found = this.byKey.get(key);
+    if (!found) return;
+    this.byKey.delete(key);
+    const scopeKeys = this.scopeIndex.get(found.scopeKey);
+    if (!scopeKeys) return;
+    scopeKeys.delete(key);
+    if (scopeKeys.size === 0) {
+      this.scopeIndex.delete(found.scopeKey);
+    }
+  }
+};
+
+// ../src/sdk/core/queue.ts
+var InMemoryQueueStore = class {
+  items = [];
+  async load() {
+    return [...this.items];
+  }
+  async save(items) {
+    this.items = [...items];
+  }
+};
+var WriteQueue = class {
+  flushHandler;
+  store;
+  maxBatchSize;
+  flushIntervalMs;
+  maxAttempts;
+  queue = [];
+  flushTimer = null;
+  flushing = false;
+  lastFlushAt;
+  lastFlushCount = 0;
+  constructor(args) {
+    this.flushHandler = args.flushHandler;
+    this.store = args.store || new InMemoryQueueStore();
+    this.maxBatchSize = Math.max(1, args.maxBatchSize ?? 50);
+    this.flushIntervalMs = Math.max(10, args.flushIntervalMs ?? 100);
+    this.maxAttempts = Math.max(1, args.maxAttempts ?? 2);
+  }
+  async start() {
+    const pending = await this.store.load();
+    if (pending.length > 0) {
+      this.queue.push(...pending);
+    }
+    if (!this.flushTimer) {
+      this.flushTimer = setInterval(() => {
+        void this.flush();
+      }, this.flushIntervalMs);
+      const timer = this.flushTimer;
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+    }
+    this.bindProcessHooks();
+  }
+  async stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  status() {
+    return {
+      queued: this.queue.length,
+      flushing: this.flushing,
+      lastFlushAt: this.lastFlushAt,
+      lastFlushCount: this.lastFlushCount
+    };
+  }
+  async enqueue(input) {
+    const eventId = input.eventId || this.makeEventId(input);
+    const item = {
+      ...input,
+      eventId,
+      createdAt: nowIso()
+    };
+    this.queue.push(item);
+    await this.store.save(this.queue);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush();
+    }
+    return item;
+  }
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    try {
+      while (this.queue.length > 0) {
+        const batch = this.queue.slice(0, this.maxBatchSize);
+        let done = false;
+        let error = null;
+        for (let attempt = 0; attempt < this.maxAttempts; attempt += 1) {
+          try {
+            await this.flushHandler(batch);
+            done = true;
+            break;
+          } catch (err) {
+            error = err;
+            await new Promise((resolve) => setTimeout(resolve, (attempt + 1) * 180));
+          }
+        }
+        if (!done) {
+          throw error instanceof Error ? error : new Error("Queue flush failed");
+        }
+        this.queue.splice(0, batch.length);
+        this.lastFlushAt = nowIso();
+        this.lastFlushCount = batch.length;
+        await this.store.save(this.queue);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  makeEventId(input) {
+    const source = JSON.stringify({
+      project: input.project,
+      userId: input.userId || "",
+      sessionId: input.sessionId || "",
+      payload: input.payload
+    });
+    return `evt_${stableHash(source)}`;
+  }
+  bindProcessHooks() {
+    if (typeof process === "undefined") return;
+    const proc = process;
+    const flushOnExit = () => {
+      void this.flush();
+    };
+    proc.once("beforeExit", flushOnExit);
+    proc.once("SIGINT", flushOnExit);
+    proc.once("SIGTERM", flushOnExit);
+  }
+};
+function createStorageQueueStore(key = "whisper_sdk_queue") {
+  const getStorage = () => {
+    const maybeStorage = globalThis.localStorage;
+    if (!maybeStorage || typeof maybeStorage !== "object") return null;
+    const candidate = maybeStorage;
+    if (typeof candidate.getItem !== "function" || typeof candidate.setItem !== "function") {
+      return null;
+    }
+    return {
+      getItem: candidate.getItem,
+      setItem: candidate.setItem
+    };
+  };
+  return {
+    async load() {
+      const storage = getStorage();
+      if (!storage) return [];
+      const raw = storage.getItem(key);
+      if (!raw) return [];
+      try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    },
+    async save(items) {
+      const storage = getStorage();
+      if (!storage) return;
+      storage.setItem(key, JSON.stringify(items));
+    }
+  };
+}
+function createFileQueueStore(filePath) {
+  return {
+    async load() {
+      if (typeof process === "undefined") return [];
+      const fs = await import("fs/promises");
+      try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch (error) {
+        const nodeError = error;
+        if (nodeError?.code === "ENOENT") {
+          return [];
+        }
+        return [];
+      }
+    },
+    async save(items) {
+      if (typeof process === "undefined") return;
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const dir = path.dirname(filePath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(filePath, JSON.stringify(items), "utf8");
+    }
+  };
+}
+
+// ../src/sdk/modules/memory.ts
+function isEndpointNotFound(error) {
+  return error instanceof RuntimeClientError && error.status === 404;
+}
+function toSotaType(memoryType) {
+  if (!memoryType) return void 0;
+  switch (memoryType) {
+    case "episodic":
+      return "event";
+    case "semantic":
+      return "factual";
+    case "procedural":
+      return "instruction";
+    default:
+      return memoryType;
+  }
+}
+function toLegacyType(memoryType) {
+  if (!memoryType) return void 0;
+  switch (memoryType) {
+    case "event":
+      return "episodic";
+    case "instruction":
+      return "procedural";
+    case "preference":
+    case "relationship":
+    case "opinion":
+    case "goal":
+      return "semantic";
+    default:
+      return memoryType;
+  }
+}
+var MemoryModule = class {
+  constructor(client, cache, queue, options = {}) {
+    this.client = client;
+    this.cache = cache;
+    this.queue = queue;
+    this.options = options;
+  }
+  resolveProject(project) {
+    const value = project || this.options.defaultProject;
+    if (!value) {
+      throw new RuntimeClientError({
+        code: "MISSING_PROJECT",
+        message: "Project is required",
+        retryable: false
+      });
+    }
+    return value;
+  }
+  invalidate(project, userId, sessionId) {
+    if (this.options.cacheEnabled === false) {
+      return;
+    }
+    const scope = this.cache.makeScopeKey(project, userId, sessionId);
+    this.cache.invalidateScope(scope);
+  }
+  async add(params) {
+    const project = this.resolveProject(params.project);
+    const queueEnabled = this.options.queueEnabled !== false;
+    const useQueue = queueEnabled && params.write_mode !== "sync" && params.async !== false;
+    if (useQueue) {
+      const queued = await this.queue.enqueue({
+        project,
+        userId: params.user_id,
+        sessionId: params.session_id,
+        payload: {
+          content: params.content,
+          memory_type: toSotaType(params.memory_type),
+          user_id: params.user_id,
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          confidence: params.confidence,
+          metadata: params.metadata,
+          document_date: params.document_date,
+          event_date: params.event_date
+        }
+      });
+      this.invalidate(project, params.user_id, params.session_id);
+      return {
+        success: true,
+        mode: "async",
+        queued: true,
+        event_id: queued.eventId,
+        accepted_at: queued.createdAt
+      };
+    }
+    try {
+      const response = await this.client.request({
+        endpoint: "/v1/memory",
+        method: "POST",
+        operation: "writeAck",
+        body: {
+          project,
+          content: params.content,
+          memory_type: toSotaType(params.memory_type),
+          user_id: params.user_id,
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          confidence: params.confidence,
+          metadata: params.metadata,
+          document_date: params.document_date,
+          event_date: params.event_date,
+          write_mode: "sync"
+        }
+      });
+      this.invalidate(project, params.user_id, params.session_id);
+      return {
+        success: true,
+        mode: "sync",
+        trace_id: response.traceId
+      };
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      await this.client.request({
+        endpoint: "/v1/memories",
+        method: "POST",
+        operation: "writeAck",
+        body: {
+          project,
+          content: params.content,
+          memory_type: toLegacyType(params.memory_type),
+          user_id: params.user_id,
+          session_id: params.session_id,
+          agent_id: params.agent_id,
+          importance: params.importance,
+          metadata: params.metadata
+        }
+      });
+      this.invalidate(project, params.user_id, params.session_id);
+      return {
+        success: true,
+        mode: "sync"
+      };
+    }
+  }
+  async addBulk(params) {
+    const project = this.resolveProject(params.project);
+    if (!Array.isArray(params.memories) || params.memories.length === 0) {
+      throw new RuntimeClientError({
+        code: "VALIDATION_ERROR",
+        message: "memories is required",
+        retryable: false
+      });
+    }
+    const queueEnabled = this.options.queueEnabled !== false;
+    const useQueue = queueEnabled && params.write_mode !== "sync" && params.async !== false;
+    if (useQueue) {
+      const queued = await Promise.all(
+        params.memories.map(
+          (memory) => this.queue.enqueue({
+            project,
+            userId: memory.user_id,
+            sessionId: memory.session_id,
+            payload: {
+              content: memory.content,
+              memory_type: toSotaType(memory.memory_type),
+              user_id: memory.user_id,
+              session_id: memory.session_id,
+              agent_id: memory.agent_id,
+              importance: memory.importance,
+              confidence: memory.confidence,
+              metadata: memory.metadata,
+              document_date: memory.document_date,
+              event_date: memory.event_date
+            }
+          })
+        )
+      );
+      for (const memory of params.memories) {
+        this.invalidate(project, memory.user_id, memory.session_id);
+      }
+      return {
+        success: true,
+        mode: "async",
+        queued: true,
+        created: queued.length
+      };
+    }
+    try {
+      const response = await this.client.request({
+        endpoint: "/v1/memory/bulk",
+        method: "POST",
+        operation: "bulk",
+        body: {
+          project,
+          memories: params.memories.map((memory) => ({
+            ...memory,
+            memory_type: toSotaType(memory.memory_type)
+          })),
+          write_mode: "sync"
+        }
+      });
+      for (const memory of params.memories) {
+        this.invalidate(project, memory.user_id, memory.session_id);
+      }
+      return {
+        success: true,
+        mode: "sync",
+        trace_id: response.traceId
+      };
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      await Promise.all(
+        params.memories.map(
+          (memory) => this.add({
+            project,
+            ...memory,
+            write_mode: "sync"
+          })
+        )
+      );
+      return {
+        success: true,
+        mode: "sync"
+      };
+    }
+  }
+  async search(params) {
+    const project = this.resolveProject(params.project);
+    const topK = params.top_k || 10;
+    const profile = params.profile || "fast";
+    const includePending = params.include_pending !== false;
+    const cacheKey = this.cache.makeKey({
+      project,
+      userId: params.user_id,
+      sessionId: params.session_id,
+      query: params.query,
+      topK,
+      profile,
+      includePending
+    });
+    if (this.options.cacheEnabled !== false) {
+      const cached = this.cache.get(cacheKey);
+      if (cached) {
+        return {
+          ...cached,
+          cache_hit: true
+        };
+      }
+    }
+    try {
+      const response = await this.client.request({
+        endpoint: "/v1/memory/search",
+        method: "POST",
+        operation: "search",
+        idempotent: true,
+        body: {
+          project,
+          query: params.query,
+          user_id: params.user_id,
+          session_id: params.session_id,
+          top_k: topK,
+          profile,
+          include_pending: includePending,
+          memory_types: params.memory_type ? [toSotaType(params.memory_type)] : void 0
+        }
+      });
+      const data = {
+        ...response.data || {},
+        cache_hit: false
+      };
+      if (this.options.cacheEnabled !== false) {
+        const scope = this.cache.makeScopeKey(project, params.user_id, params.session_id);
+        this.cache.set(cacheKey, scope, data);
+      }
+      return data;
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      const legacy = await this.client.request({
+        endpoint: "/v1/memories/search",
+        method: "POST",
+        operation: "search",
+        idempotent: true,
+        body: {
+          project,
+          query: params.query,
+          user_id: params.user_id,
+          session_id: params.session_id,
+          top_k: topK,
+          memory_type: toLegacyType(params.memory_type)
+        }
+      });
+      const data = {
+        ...legacy.data || {},
+        cache_hit: false
+      };
+      if (this.options.cacheEnabled !== false) {
+        const scope = this.cache.makeScopeKey(project, params.user_id, params.session_id);
+        this.cache.set(cacheKey, scope, data);
+      }
+      return data;
+    }
+  }
+  async getUserProfile(params) {
+    const project = this.resolveProject(params.project);
+    const query = new URLSearchParams({
+      project,
+      ...params.include_pending !== void 0 ? { include_pending: String(params.include_pending) } : {},
+      ...params.memory_types ? { memory_types: params.memory_types } : {}
+    });
+    try {
+      const response = await this.client.request({
+        endpoint: `/v1/memory/profile/${params.user_id}?${query}`,
+        method: "GET",
+        operation: "profile",
+        idempotent: true
+      });
+      return response.data;
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      const legacyQuery = new URLSearchParams({
+        project,
+        user_id: params.user_id,
+        limit: "200"
+      });
+      const legacy = await this.client.request({
+        endpoint: `/v1/memories?${legacyQuery}`,
+        method: "GET",
+        operation: "profile",
+        idempotent: true
+      });
+      const memories = Array.isArray(legacy.data?.memories) ? legacy.data.memories : [];
+      return {
+        user_id: params.user_id,
+        memories,
+        count: memories.length
+      };
+    }
+  }
+  async getSessionMemories(params) {
+    const project = this.resolveProject(params.project);
+    const query = new URLSearchParams({
+      project,
+      ...params.limit ? { limit: String(params.limit) } : {},
+      ...params.include_pending !== void 0 ? { include_pending: String(params.include_pending) } : {}
+    });
+    const response = await this.client.request({
+      endpoint: `/v1/memory/session/${params.session_id}?${query}`,
+      method: "GET",
+      operation: "profile",
+      idempotent: true
+    });
+    return response.data;
+  }
+  async update(memoryId, params) {
+    try {
+      await this.client.request({
+        endpoint: `/v1/memory/${memoryId}`,
+        method: "PUT",
+        operation: "writeAck",
+        body: params
+      });
+      return { success: true };
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      await this.client.request({
+        endpoint: `/v1/memories/${memoryId}`,
+        method: "PUT",
+        operation: "writeAck",
+        body: { content: params.content }
+      });
+      return { success: true };
+    }
+  }
+  async delete(memoryId) {
+    try {
+      await this.client.request({
+        endpoint: `/v1/memory/${memoryId}`,
+        method: "DELETE",
+        operation: "writeAck"
+      });
+      return { success: true, deleted: memoryId };
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      await this.client.request({
+        endpoint: `/v1/memories/${memoryId}`,
+        method: "DELETE",
+        operation: "writeAck"
+      });
+      return { success: true, deleted: memoryId };
+    }
+  }
+  async flag(params) {
+    try {
+      await this.client.request({
+        endpoint: `/v1/memory/${params.memoryId}/flag`,
+        method: "POST",
+        operation: "writeAck",
+        body: {
+          reason: params.reason,
+          severity: params.severity || "medium"
+        }
+      });
+      return { success: true };
+    } catch (error) {
+      if (this.client.getCompatMode() !== "fallback" || !isEndpointNotFound(error)) {
+        throw error;
+      }
+      await this.client.request({
+        endpoint: `/v1/memory/${params.memoryId}`,
+        method: "PUT",
+        operation: "writeAck",
+        body: {
+          content: `[FLAGGED:${params.severity || "medium"}] ${params.reason}`
+        }
+      });
+      return { success: true };
+    }
+  }
+};
+
+// ../src/sdk/modules/session.ts
+function randomSessionId() {
+  return `sess_${stableHash(`${Date.now()}_${Math.random()}`)}`;
+}
+function assertTransition(current, next) {
+  const allowed = {
+    created: ["active", "ended", "archived"],
+    active: ["suspended", "ended", "archived"],
+    suspended: ["resumed", "ended", "archived"],
+    resumed: ["suspended", "ended", "archived"],
+    ended: ["archived"],
+    archived: []
+  };
+  if (!allowed[current].includes(next)) {
+    throw new RuntimeClientError({
+      code: "INVALID_SESSION_STATE",
+      message: `Invalid session transition ${current} -> ${next}`,
+      retryable: false
+    });
+  }
+}
+var SessionModule = class {
+  constructor(memory, defaultProject) {
+    this.memory = memory;
+    this.defaultProject = defaultProject;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  resolveProject(project) {
+    const value = project || this.defaultProject;
+    if (!value) {
+      throw new RuntimeClientError({
+        code: "MISSING_PROJECT",
+        message: "Project is required",
+        retryable: false
+      });
+    }
+    return value;
+  }
+  ensure(sessionId) {
+    const found = this.sessions.get(sessionId);
+    if (!found) {
+      throw new RuntimeClientError({
+        code: "SESSION_NOT_FOUND",
+        message: `Unknown session ${sessionId}`,
+        retryable: false
+      });
+    }
+    return found;
+  }
+  async start(params) {
+    const project = this.resolveProject(params.project);
+    const sessionId = params.sessionId || randomSessionId();
+    const now = nowIso();
+    const record = {
+      sessionId,
+      project,
+      userId: params.userId,
+      state: "active",
+      sequence: 0,
+      metadata: params.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.sessions.set(sessionId, record);
+    return {
+      sessionId,
+      state: record.state,
+      createdAt: now
+    };
+  }
+  async event(params) {
+    const session = this.ensure(params.sessionId);
+    if (session.state !== "active" && session.state !== "resumed") {
+      throw new RuntimeClientError({
+        code: "INVALID_SESSION_STATE",
+        message: `Cannot append event in ${session.state} state`,
+        retryable: false
+      });
+    }
+    session.sequence += 1;
+    session.updatedAt = nowIso();
+    const eventId = `evt_${stableHash(JSON.stringify({
+      sessionId: session.sessionId,
+      seq: session.sequence,
+      type: params.type,
+      content: params.content,
+      parent: params.parentEventId || ""
+    }))}`;
+    await this.memory.add({
+      project: session.project,
+      content: `${params.type}: ${params.content}`,
+      memory_type: "event",
+      user_id: session.userId,
+      session_id: session.sessionId,
+      metadata: {
+        session_event: true,
+        event_id: eventId,
+        sequence: session.sequence,
+        parent_event_id: params.parentEventId,
+        ...session.metadata,
+        ...params.metadata || {}
+      },
+      write_mode: "async"
+    });
+    return {
+      success: true,
+      eventId,
+      sequence: session.sequence
+    };
+  }
+  async suspend(params) {
+    const session = this.ensure(params.sessionId);
+    assertTransition(session.state, "suspended");
+    session.state = "suspended";
+    session.updatedAt = nowIso();
+    return { sessionId: session.sessionId, state: session.state };
+  }
+  async resume(params) {
+    const session = this.ensure(params.sessionId);
+    const target = session.state === "suspended" ? "resumed" : "active";
+    assertTransition(session.state, target);
+    session.state = target;
+    session.updatedAt = nowIso();
+    return { sessionId: session.sessionId, state: session.state };
+  }
+  async end(params) {
+    const session = this.ensure(params.sessionId);
+    assertTransition(session.state, "ended");
+    session.state = "ended";
+    session.updatedAt = nowIso();
+    return { sessionId: session.sessionId, state: session.state };
+  }
+  async archive(params) {
+    const session = this.ensure(params.sessionId);
+    assertTransition(session.state, "archived");
+    session.state = "archived";
+    session.updatedAt = nowIso();
+    return { sessionId: session.sessionId, state: session.state };
+  }
+};
+
+// ../src/sdk/modules/profile.ts
+var ProfileModule = class {
+  constructor(memory) {
+    this.memory = memory;
+  }
+  async getUserProfile(params) {
+    return this.memory.getUserProfile(params);
+  }
+  async getSessionMemories(params) {
+    return this.memory.getSessionMemories(params);
+  }
+};
+
+// ../src/sdk/modules/analytics.ts
+var AnalyticsModule = class {
+  constructor(diagnostics, queue) {
+    this.diagnostics = diagnostics;
+    this.queue = queue;
+  }
+  diagnosticsSnapshot() {
+    return this.diagnostics.snapshot();
+  }
+  queueStatus() {
+    return this.queue.status();
+  }
+};
+
+// ../src/sdk/whisper.ts
+var WhisperClient = class _WhisperClient {
+  constructor(config) {
+    this.config = config;
+    this.diagnosticsStore = new DiagnosticsStore(config.telemetry?.maxEntries || 1e3);
+    this.runtimeClient = new RuntimeClient(
+      {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        compatMode: config.compatMode || "fallback",
+        timeouts: config.timeouts,
+        retryPolicy: config.retryPolicy
+      },
+      this.diagnosticsStore
+    );
+    this.searchCache = new SearchResponseCache(
+      config.cache?.ttlMs ?? 7e3,
+      config.cache?.capacity ?? 500
+    );
+    const queueStore = config.queue?.persistence === "storage" ? createStorageQueueStore() : config.queue?.persistence === "file" && config.queue.filePath ? createFileQueueStore(config.queue.filePath) : new InMemoryQueueStore();
+    this.writeQueue = new WriteQueue({
+      store: queueStore,
+      maxBatchSize: config.queue?.maxBatchSize ?? 50,
+      flushIntervalMs: config.queue?.flushIntervalMs ?? 100,
+      maxAttempts: config.queue?.maxAttempts ?? 2,
+      flushHandler: async (items) => {
+        if (items.length === 0) return;
+        const project = items[0].project;
+        const memories = items.map((item) => ({
+          ...item.payload,
+          user_id: item.payload.user_id ?? item.userId,
+          session_id: item.payload.session_id ?? item.sessionId,
+          metadata: {
+            ...item.payload.metadata || {},
+            event_id: item.eventId,
+            queued_at: item.createdAt
+          }
+        }));
+        try {
+          await this.runtimeClient.request({
+            endpoint: "/v1/memory/bulk",
+            method: "POST",
+            operation: "bulk",
+            body: {
+              project,
+              write_mode: "async",
+              memories
+            }
+          });
+        } catch (error) {
+          if (this.runtimeClient.getCompatMode() !== "fallback" || !(error instanceof RuntimeClientError) || error.status !== 404) {
+            throw error;
+          }
+          await Promise.all(
+            memories.map(async (memory) => {
+              try {
+                await this.runtimeClient.request({
+                  endpoint: "/v1/memory",
+                  method: "POST",
+                  operation: "writeAck",
+                  body: {
+                    project,
+                    ...memory,
+                    write_mode: "sync"
+                  }
+                });
+              } catch (fallbackError) {
+                if (this.runtimeClient.getCompatMode() !== "fallback" || !(fallbackError instanceof RuntimeClientError) || fallbackError.status !== 404) {
+                  throw fallbackError;
+                }
+                await this.runtimeClient.request({
+                  endpoint: "/v1/memories",
+                  method: "POST",
+                  operation: "writeAck",
+                  body: {
+                    project,
+                    ...memory,
+                    memory_type: memory.memory_type === "event" ? "episodic" : memory.memory_type
+                  }
+                });
+              }
+            })
+          );
+        }
+      }
+    });
+    if (config.queue?.enabled !== false) {
+      void this.writeQueue.start();
+    }
+    this.memoryModule = new MemoryModule(
+      this.runtimeClient,
+      this.searchCache,
+      this.writeQueue,
+      {
+        defaultProject: config.project,
+        cacheEnabled: config.cache?.enabled !== false,
+        queueEnabled: config.queue?.enabled !== false
+      }
+    );
+    this.sessionModule = new SessionModule(this.memoryModule, config.project);
+    this.profileModule = new ProfileModule(this.memoryModule);
+    this.analyticsModule = new AnalyticsModule(this.diagnosticsStore, this.writeQueue);
+    this.diagnostics = {
+      getLast: (limit) => this.diagnosticsStore.getLast(limit),
+      subscribe: (fn) => this.diagnosticsStore.subscribe(fn),
+      snapshot: () => this.diagnosticsStore.snapshot()
+    };
+    this.queue = {
+      flush: () => this.writeQueue.flush(),
+      status: () => this.writeQueue.status()
+    };
+    this.memory = {
+      add: (params) => this.memoryModule.add(params),
+      addBulk: (params) => this.memoryModule.addBulk(params),
+      search: (params) => this.memoryModule.search(params),
+      getUserProfile: (params) => this.memoryModule.getUserProfile(params),
+      getSessionMemories: (params) => this.memoryModule.getSessionMemories(params),
+      update: (memoryId, params) => this.memoryModule.update(memoryId, params),
+      delete: (memoryId) => this.memoryModule.delete(memoryId),
+      flag: (params) => this.memoryModule.flag(params)
+    };
+    this.session = {
+      start: (params) => this.sessionModule.start(params),
+      event: (params) => this.sessionModule.event(params),
+      suspend: (params) => this.sessionModule.suspend(params),
+      resume: (params) => this.sessionModule.resume(params),
+      end: (params) => this.sessionModule.end(params)
+    };
+    this.profile = {
+      getUserProfile: (params) => this.profileModule.getUserProfile(params),
+      getSessionMemories: (params) => this.profileModule.getSessionMemories(params)
+    };
+    this.analytics = {
+      diagnosticsSnapshot: () => this.analyticsModule.diagnosticsSnapshot(),
+      queueStatus: () => this.analyticsModule.queueStatus()
+    };
+  }
+  diagnostics;
+  queue;
+  memory;
+  session;
+  profile;
+  analytics;
+  runtimeClient;
+  diagnosticsStore;
+  searchCache;
+  writeQueue;
+  memoryModule;
+  sessionModule;
+  profileModule;
+  analyticsModule;
+  static fromEnv(overrides = {}) {
+    const env = typeof process !== "undefined" ? process.env : {};
+    const apiKey = overrides.apiKey || env.WHISPER_API_KEY || env.USEWHISPER_API_KEY || env.API_KEY;
+    if (!apiKey) {
+      throw new Error("Missing API key. Set WHISPER_API_KEY / USEWHISPER_API_KEY / API_KEY.");
     }
-    return Array.from(new Set(ids));
+    return new _WhisperClient({
+      apiKey,
+      baseUrl: overrides.baseUrl || env.WHISPER_BASE_URL || env.API_BASE_URL || "https://context.usewhisper.dev",
+      project: overrides.project || env.WHISPER_PROJECT || env.PROJECT,
+      ...overrides
+    });
+  }
+  withRunContext(context) {
+    const base = this;
+    return {
+      memory: {
+        add: (params) => base.memory.add({
+          ...params,
+          project: params.project || context.project || base.config.project,
+          user_id: params.user_id || context.userId,
+          session_id: params.session_id || context.sessionId
+        }),
+        search: (params) => base.memory.search({
+          ...params,
+          project: params.project || context.project || base.config.project,
+          user_id: params.user_id || context.userId,
+          session_id: params.session_id || context.sessionId
+        })
+      },
+      session: {
+        event: (params) => base.session.event({
+          ...params,
+          sessionId: params.sessionId || context.sessionId || ""
+        })
+      },
+      queue: base.queue,
+      diagnostics: base.diagnostics
+    };
+  }
+  async shutdown() {
+    await this.writeQueue.stop();
   }
 };
-var whisper_agent_default = Whisper;
+var whisper_default = WhisperClient;
 
 // ../src/sdk/middleware.ts
 var WhisperAgentMiddleware = class {
@@ -347,14 +1823,409 @@ function createAgentMiddleware(config) {
   return new WhisperAgentMiddleware(config);
 }
 
+// ../src/sdk/adapters/langchain.ts
+var LangChainMemoryAdapter = class {
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+    this.memoryKey = options.memoryKey || "history";
+    this.memoryKeys = [this.memoryKey];
+  }
+  memoryKeys;
+  memoryKey;
+  async loadMemoryVariables(_inputValues) {
+    const response = await this.client.memory.search({
+      project: this.options.project,
+      query: "recent context",
+      user_id: this.options.userId,
+      session_id: this.options.sessionId,
+      top_k: this.options.topK || 10,
+      profile: this.options.profile || "fast",
+      include_pending: true
+    });
+    const content = (response.results || []).map((row) => row.memory?.content || "").filter(Boolean).join("\n");
+    return {
+      [this.memoryKey]: content
+    };
+  }
+  async saveContext(inputValues, outputValues) {
+    const userInput = typeof inputValues.input === "string" ? inputValues.input : JSON.stringify(inputValues);
+    const output = typeof outputValues.output === "string" ? outputValues.output : JSON.stringify(outputValues);
+    await this.client.memory.addBulk({
+      project: this.options.project,
+      write_mode: "async",
+      memories: [
+        {
+          content: `user: ${userInput}`,
+          memory_type: "event",
+          user_id: this.options.userId,
+          session_id: this.options.sessionId
+        },
+        {
+          content: `assistant: ${output}`,
+          memory_type: "event",
+          user_id: this.options.userId,
+          session_id: this.options.sessionId
+        }
+      ]
+    });
+  }
+  async clear() {
+    const profile = await this.client.memory.getUserProfile({
+      project: this.options.project,
+      user_id: this.options.userId
+    });
+    await Promise.all(
+      (profile.memories || []).map((memory) => String(memory.id || "")).filter(Boolean).map((id) => this.client.memory.delete(id))
+    );
+  }
+};
+function createLangChainMemoryAdapter(client, options) {
+  return new LangChainMemoryAdapter(client, options);
+}
+
+// ../src/sdk/adapters/langgraph.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function isTupleLike(value) {
+  if (!value || typeof value !== "object") return false;
+  const tuple = value;
+  const config = asRecord(tuple.config);
+  const configurable = asRecord(config.configurable);
+  return Boolean(
+    typeof configurable.thread_id === "string" && tuple.checkpoint && typeof tuple.checkpoint === "object"
+  );
+}
+function tupleTimestamp(tuple, fallback) {
+  const checkpoint = asRecord(tuple.checkpoint);
+  const metadata = asRecord(tuple.metadata);
+  const sources = [
+    checkpoint.updatedAt,
+    checkpoint.updated_at,
+    checkpoint.ts,
+    checkpoint.timestamp,
+    metadata.updatedAt,
+    metadata.updated_at,
+    metadata.ts,
+    metadata.timestamp,
+    fallback
+  ];
+  for (const source of sources) {
+    const parsed = source ? new Date(String(source)).getTime() : Number.NaN;
+    if (!Number.isNaN(parsed) && parsed > 0) return parsed;
+  }
+  return 0;
+}
+function metadataMatches(target, filter) {
+  if (!filter || Object.keys(filter).length === 0) return true;
+  const value = target || {};
+  return Object.entries(filter).every(([key, expected]) => {
+    if (!(key in value)) return false;
+    return JSON.stringify(value[key]) === JSON.stringify(expected);
+  });
+}
+var LangGraphCheckpointAdapter = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  localByKey = /* @__PURE__ */ new Map();
+  localByThread = /* @__PURE__ */ new Map();
+  options;
+  getUserId(threadId) {
+    const prefix = this.options.userIdPrefix || "langgraph-thread";
+    return `${prefix}:${threadId}`;
+  }
+  resolveCheckpointNs(config) {
+    return config.configurable.checkpoint_ns || this.options.defaultCheckpointNs || "default";
+  }
+  makeLocalKey(threadId, checkpointNs, checkpointId) {
+    return `${threadId}:${checkpointNs}:${checkpointId}`;
+  }
+  normalizeTuple(tuple) {
+    const config = asRecord(tuple.config);
+    const configurable = asRecord(config.configurable);
+    const threadId = text(configurable.thread_id) || "";
+    const checkpointNs = text(configurable.checkpoint_ns) || this.options.defaultCheckpointNs || "default";
+    const checkpointId = text(configurable.checkpoint_id) || "";
+    return {
+      config: {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id: checkpointId || void 0
+        }
+      },
+      checkpoint: asRecord(tuple.checkpoint),
+      metadata: asRecord(tuple.metadata),
+      parent_config: tuple.parent_config ? {
+        configurable: {
+          thread_id: text(tuple.parent_config.configurable.thread_id) || "",
+          checkpoint_ns: text(tuple.parent_config.configurable.checkpoint_ns) || checkpointNs,
+          checkpoint_id: text(tuple.parent_config.configurable.checkpoint_id)
+        }
+      } : null
+    };
+  }
+  parseCheckpointTupleFromRow(row) {
+    const rowMetadata = asRecord(row.metadata);
+    const marker = rowMetadata.langgraph_checkpoint === true;
+    const rawContent = text(row.content) || "";
+    if (!rawContent) return null;
+    try {
+      const parsed = JSON.parse(rawContent);
+      let tuple = null;
+      if (isTupleLike(parsed)) {
+        tuple = this.normalizeTuple(parsed);
+      } else {
+        const wrapped = asRecord(parsed);
+        if (isTupleLike(wrapped.tuple)) {
+          tuple = this.normalizeTuple(wrapped.tuple);
+        }
+      }
+      if (!tuple) return null;
+      const config = tuple.config.configurable;
+      if (!config.thread_id) return null;
+      if (!config.checkpoint_id) return null;
+      if (!marker && rowMetadata.checkpoint_id !== config.checkpoint_id) {
+        return null;
+      }
+      return {
+        tuple,
+        memoryId: text(row.id),
+        createdAt: text(row.createdAt) || text(row.created_at),
+        updatedAt: text(row.updatedAt) || text(row.updated_at)
+      };
+    } catch {
+      return null;
+    }
+  }
+  upsertLocal(record) {
+    const cfg = record.tuple.config.configurable;
+    const key = this.makeLocalKey(cfg.thread_id, cfg.checkpoint_ns || "default", cfg.checkpoint_id || "");
+    this.localByKey.set(key, record);
+    if (!this.localByThread.has(cfg.thread_id)) {
+      this.localByThread.set(cfg.thread_id, /* @__PURE__ */ new Set());
+    }
+    this.localByThread.get(cfg.thread_id).add(key);
+  }
+  mergeWithLocal(records, threadId) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const cfg = record.tuple.config.configurable;
+      const key = this.makeLocalKey(cfg.thread_id, cfg.checkpoint_ns || "default", cfg.checkpoint_id || "");
+      merged.set(key, record);
+    }
+    const localKeys = this.localByThread.get(threadId);
+    if (localKeys) {
+      for (const key of localKeys) {
+        const local = this.localByKey.get(key);
+        if (local) {
+          merged.set(key, local);
+        }
+      }
+    }
+    return Array.from(merged.values());
+  }
+  applyListFilters(records, options) {
+    let filtered = records;
+    if (options?.filter?.checkpointNs) {
+      filtered = filtered.filter(
+        (record) => (record.tuple.config.configurable.checkpoint_ns || "default") === options.filter.checkpointNs
+      );
+    }
+    if (options?.filter?.metadata) {
+      filtered = filtered.filter((record) => metadataMatches(record.tuple.metadata, options.filter.metadata));
+    }
+    if (options?.before?.checkpointId) {
+      const beforeId = options.before.checkpointId;
+      filtered = filtered.filter(
+        (record) => record.tuple.config.configurable.checkpoint_id !== beforeId
+      );
+    }
+    if (options?.before?.updatedAt) {
+      const cutoff = new Date(options.before.updatedAt).getTime();
+      if (!Number.isNaN(cutoff)) {
+        filtered = filtered.filter((record) => {
+          const value = tupleTimestamp(record.tuple, record.updatedAt || record.createdAt);
+          return value < cutoff;
+        });
+      }
+    }
+    const direction = options?.sort || "desc";
+    filtered.sort((a, b) => {
+      const ta = tupleTimestamp(a.tuple, a.updatedAt || a.createdAt);
+      const tb = tupleTimestamp(b.tuple, b.updatedAt || b.createdAt);
+      return direction === "asc" ? ta - tb : tb - ta;
+    });
+    if (options?.limit && options.limit > 0) {
+      return filtered.slice(0, options.limit);
+    }
+    return filtered;
+  }
+  async fetchThreadRecords(threadId) {
+    const profile = await this.client.memory.getUserProfile({
+      project: this.options.project,
+      user_id: this.getUserId(threadId),
+      include_pending: true
+    });
+    const parsed = (profile.memories || []).map((row) => this.parseCheckpointTupleFromRow(row)).filter((value) => value !== null).filter((record) => record.tuple.config.configurable.thread_id === threadId);
+    const merged = this.mergeWithLocal(parsed, threadId);
+    for (const record of merged) {
+      this.upsertLocal(record);
+    }
+    return merged;
+  }
+  async get(config) {
+    const threadId = config.configurable.thread_id;
+    const checkpointNs = this.resolveCheckpointNs(config);
+    const checkpointId = config.configurable.checkpoint_id;
+    if (checkpointId) {
+      const local = this.localByKey.get(this.makeLocalKey(threadId, checkpointNs, checkpointId));
+      if (local) return local.tuple;
+    }
+    const records = await this.fetchThreadRecords(threadId);
+    const scoped = records.filter((record) => {
+      const cfg = record.tuple.config.configurable;
+      if ((cfg.checkpoint_ns || "default") !== checkpointNs) return false;
+      if (!checkpointId) return true;
+      return cfg.checkpoint_id === checkpointId;
+    });
+    if (scoped.length === 0) return void 0;
+    scoped.sort((a, b) => {
+      const ta = tupleTimestamp(a.tuple, a.updatedAt || a.createdAt);
+      const tb = tupleTimestamp(b.tuple, b.updatedAt || b.createdAt);
+      return tb - ta;
+    });
+    return scoped[0].tuple;
+  }
+  async put(config, checkpoint, metadata, parentConfig) {
+    const threadId = config.configurable.thread_id;
+    const checkpointNs = this.resolveCheckpointNs(config);
+    const checkpointId = config.configurable.checkpoint_id || text(checkpoint.id) || `cp_${stableHash(JSON.stringify({
+      threadId,
+      checkpointNs,
+      checkpoint,
+      metadata: metadata || {},
+      parentConfig: parentConfig || null
+    }))}`;
+    const tuple = this.normalizeTuple({
+      config: {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id: checkpointId
+        }
+      },
+      checkpoint: {
+        ...checkpoint,
+        id: checkpointId
+      },
+      metadata: {
+        ...metadata || {},
+        checkpoint_ns: checkpointNs,
+        written_at: nowIso()
+      },
+      parent_config: parentConfig ? this.normalizeTuple({
+        config: parentConfig,
+        checkpoint: {},
+        metadata: {},
+        parent_config: null
+      }).config : null
+    });
+    const record = { tuple, updatedAt: nowIso() };
+    this.upsertLocal(record);
+    await this.client.memory.add({
+      project: this.options.project,
+      user_id: this.getUserId(threadId),
+      session_id: threadId,
+      memory_type: "event",
+      write_mode: "async",
+      content: JSON.stringify(tuple),
+      metadata: {
+        langgraph_checkpoint: true,
+        thread_id: threadId,
+        checkpoint_ns: checkpointNs,
+        checkpoint_id: checkpointId,
+        parent_checkpoint_id: parentConfig?.configurable.checkpoint_id
+      }
+    });
+    return tuple.config;
+  }
+  async list(config, options) {
+    const threadId = config.configurable.thread_id;
+    const checkpointNs = this.resolveCheckpointNs(config);
+    const records = await this.fetchThreadRecords(threadId);
+    const scoped = records.filter(
+      (record) => (record.tuple.config.configurable.checkpoint_ns || "default") === checkpointNs
+    );
+    return this.applyListFilters(scoped, options).map((record) => record.tuple);
+  }
+  async search(params) {
+    const includePending = params.includePending !== false;
+    const profile = params.profile || "fast";
+    const checkpointNs = params.checkpointNs || this.options.defaultCheckpointNs || "default";
+    const response = await this.client.memory.search({
+      project: this.options.project,
+      query: params.query,
+      user_id: this.getUserId(params.threadId),
+      session_id: params.threadId,
+      top_k: params.topK || 10,
+      include_pending: includePending,
+      profile
+    });
+    const serverHits = (response.results || []).map((row) => {
+      const content = text(row.memory?.content);
+      if (!content) return null;
+      try {
+        const parsed = JSON.parse(content);
+        if (!isTupleLike(parsed)) return null;
+        const tuple = this.normalizeTuple(parsed);
+        const ns = tuple.config.configurable.checkpoint_ns || "default";
+        if (tuple.config.configurable.thread_id !== params.threadId) return null;
+        if (ns !== checkpointNs) return null;
+        return { tuple, score: row.similarity || 0 };
+      } catch {
+        return null;
+      }
+    }).filter((value) => value !== null);
+    const merged = /* @__PURE__ */ new Map();
+    for (const hit of serverHits) {
+      const cfg = hit.tuple.config.configurable;
+      const key = this.makeLocalKey(cfg.thread_id, cfg.checkpoint_ns || "default", cfg.checkpoint_id || "");
+      merged.set(key, hit);
+    }
+    const localKeys = this.localByThread.get(params.threadId);
+    if (localKeys && includePending) {
+      for (const key of localKeys) {
+        const local = this.localByKey.get(key);
+        if (!local) continue;
+        const cfg = local.tuple.config.configurable;
+        if ((cfg.checkpoint_ns || "default") !== checkpointNs) continue;
+        if (!merged.has(key)) {
+          merged.set(key, { tuple: local.tuple, score: 0 });
+        }
+      }
+    }
+    return Array.from(merged.values()).sort((a, b) => b.score - a.score).map((row) => row.tuple).slice(0, params.topK || 10);
+  }
+};
+function createLangGraphCheckpointAdapter(client, options = {}) {
+  return new LangGraphCheckpointAdapter(client, options);
+}
+
 // ../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)}...`;
+  const text2 = (input || "").replace(/\s+/g, " ").trim();
+  if (text2.length <= max) return text2;
+  return `${text2.slice(0, max - 3)}...`;
 }
 function memoryGraphToMermaid(graph) {
   const lines = ["flowchart LR"];
@@ -392,36 +2263,42 @@ var DEFAULT_BASE_DELAY_MS = 250;
 var DEFAULT_MAX_DELAY_MS = 2e3;
 var DEFAULT_TIMEOUT_MS = 15e3;
 var PROJECT_CACHE_TTL_MS = 3e4;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getBackoffDelay(attempt, base, max) {
-  const jitter = 0.8 + Math.random() * 0.4;
-  return Math.min(max, Math.floor(base * Math.pow(2, attempt) * jitter));
+var DEPRECATION_WARNINGS2 = /* @__PURE__ */ new Set();
+function warnDeprecatedOnce2(key, message) {
+  if (DEPRECATION_WARNINGS2.has(key)) return;
+  DEPRECATION_WARNINGS2.add(key);
+  if (typeof console !== "undefined" && typeof console.warn === "function") {
+    console.warn(message);
+  }
 }
 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) {
+function normalizeBaseUrl2(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) {
+function normalizeEndpoint2(endpoint) {
   const withLeadingSlash = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
   if (/^\/api\/v1(\/|$)/i.test(withLeadingSlash)) {
     return withLeadingSlash.replace(/^\/api/i, "");
   }
   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;
   defaultProject;
   timeoutMs;
   retryConfig;
+  runtimeClient;
   projectRefToId = /* @__PURE__ */ new Map();
   projectCache = [];
   projectCacheExpiresAt = 0;
@@ -433,7 +2310,7 @@ var WhisperContext = class _WhisperContext {
       });
     }
     this.apiKey = config.apiKey;
-    this.baseUrl = normalizeBaseUrl(config.baseUrl || "https://context.usewhisper.dev");
+    this.baseUrl = normalizeBaseUrl2(config.baseUrl || "https://context.usewhisper.dev");
     this.defaultProject = config.project;
     this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.retryConfig = {
@@ -441,6 +2318,35 @@ var WhisperContext = class _WhisperContext {
       baseDelayMs: config.retry?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS,
       maxDelayMs: config.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS
     };
+    this.runtimeClient = new RuntimeClient({
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      compatMode: "fallback",
+      timeouts: {
+        searchMs: this.timeoutMs,
+        writeAckMs: this.timeoutMs,
+        bulkMs: Math.max(this.timeoutMs, 1e4),
+        profileMs: this.timeoutMs,
+        sessionMs: this.timeoutMs
+      },
+      retryPolicy: {
+        baseBackoffMs: this.retryConfig.baseDelayMs,
+        maxBackoffMs: this.retryConfig.maxDelayMs,
+        maxAttemptsByOperation: {
+          search: this.retryConfig.maxAttempts,
+          writeAck: this.retryConfig.maxAttempts,
+          bulk: this.retryConfig.maxAttempts,
+          profile: this.retryConfig.maxAttempts,
+          session: this.retryConfig.maxAttempts,
+          query: this.retryConfig.maxAttempts,
+          get: this.retryConfig.maxAttempts
+        }
+      }
+    });
+    warnDeprecatedOnce2(
+      "whisper_context_class",
+      "[Whisper SDK] WhisperContext remains supported in v2 but is legacy. Prefer WhisperClient for runtime features (queue/cache/session/diagnostics)."
+    );
   }
   withProject(project) {
     return new _WhisperContext({
@@ -522,9 +2428,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) {
@@ -547,7 +2461,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) {
@@ -561,72 +2475,68 @@ 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);
+  }
+  inferOperation(endpoint, method) {
+    const normalized = normalizeEndpoint2(endpoint).toLowerCase();
+    if (normalized.includes("/memory/search")) return "search";
+    if (normalized.includes("/memory/bulk")) return "bulk";
+    if (normalized.includes("/memory/profile") || normalized.includes("/memory/session")) return "profile";
+    if (normalized.includes("/memory/ingest/session")) return "session";
+    if (normalized.includes("/context/query")) return "query";
+    if (method === "GET") return "get";
+    return "writeAck";
+  }
   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);
+    const method = String(options.method || "GET").toUpperCase();
+    const normalizedEndpoint = normalizeEndpoint2(endpoint);
+    const operation = this.inferOperation(normalizedEndpoint, method);
+    let body;
+    if (typeof options.body === "string") {
       try {
-        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
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-          let payload = null;
-          try {
-            payload = await response.json();
-          } catch {
-            payload = await response.text().catch(() => "");
-          }
-          const message = typeof payload === "string" ? payload : payload?.error || payload?.message || `HTTP ${response.status}: ${response.statusText}`;
-          const { code, retryable } = this.classifyError(response.status, message);
-          const err = new WhisperError({
-            code,
-            message,
-            status: response.status,
-            retryable,
-            details: payload
-          });
-          if (!retryable || attempt === maxAttempts - 1) {
-            throw err;
-          }
-          await sleep(getBackoffDelay(attempt, this.retryConfig.baseDelayMs, this.retryConfig.maxDelayMs));
-          continue;
-        }
-        return response.json();
-      } catch (error) {
-        clearTimeout(timeout);
-        const isAbort = error?.name === "AbortError";
-        const mapped = error instanceof WhisperError ? error : new WhisperError({
-          code: isAbort ? "TIMEOUT" : "NETWORK_ERROR",
-          message: isAbort ? "Request timed out" : error?.message || "Network request failed",
-          retryable: true,
-          details: error
-        });
-        lastError = mapped;
-        if (!mapped.retryable || attempt === maxAttempts - 1) {
-          throw mapped;
-        }
-        await sleep(getBackoffDelay(attempt, this.retryConfig.baseDelayMs, this.retryConfig.maxDelayMs));
+        body = JSON.parse(options.body);
+      } catch {
+        body = void 0;
       }
+    } else if (options.body && typeof options.body === "object" && !ArrayBuffer.isView(options.body) && !(options.body instanceof ArrayBuffer) && !(options.body instanceof FormData) && !(options.body instanceof URLSearchParams) && !(options.body instanceof Blob) && !(options.body instanceof ReadableStream)) {
+      body = options.body;
+    }
+    try {
+      const response = await this.runtimeClient.request({
+        endpoint: normalizedEndpoint,
+        method,
+        operation,
+        idempotent: method === "GET" || method === "POST" && (operation === "search" || operation === "query" || operation === "profile"),
+        body,
+        headers: options.headers || {}
+      });
+      return response.data;
+    } catch (error) {
+      if (!(error instanceof RuntimeClientError)) {
+        throw error;
+      }
+      let message = error.message;
+      if (error.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(error.status, message);
+      throw new WhisperError({
+        code,
+        message,
+        status: error.status,
+        retryable,
+        details: error.details
+      });
     }
-    throw lastError instanceof Error ? lastError : new WhisperError({ code: "REQUEST_FAILED", message: "Request failed" });
   }
   async query(params) {
     const projectRef = this.getRequiredProject(params.project);
@@ -699,7 +2609,7 @@ var WhisperContext = class _WhisperContext {
   async addMemory(params) {
     const projectRef = this.getRequiredProject(params.project);
     return this.withProjectRefFallback(projectRef, async (project) => {
-      const toSotaType = (memoryType) => {
+      const toSotaType2 = (memoryType) => {
         switch (memoryType) {
           case "episodic":
             return "event";
@@ -711,7 +2621,7 @@ var WhisperContext = class _WhisperContext {
             return memoryType;
         }
       };
-      const toLegacyType = (memoryType) => {
+      const toLegacyType2 = (memoryType) => {
         switch (memoryType) {
           case "event":
             return "episodic";
@@ -732,18 +2642,23 @@ var WhisperContext = class _WhisperContext {
           body: JSON.stringify({
             project,
             content: params.content,
-            memory_type: toSotaType(params.memory_type),
+            memory_type: toSotaType2(params.memory_type),
             user_id: params.user_id,
             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;
@@ -754,7 +2669,7 @@ var WhisperContext = class _WhisperContext {
         body: JSON.stringify({
           project,
           content: params.content,
-          memory_type: toLegacyType(params.memory_type),
+          memory_type: toLegacyType2(params.memory_type),
           user_id: params.user_id,
           session_id: params.session_id,
           agent_id: params.agent_id,
@@ -775,10 +2690,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);
@@ -803,17 +2748,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", {
@@ -829,10 +2805,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);
@@ -842,33 +2837,92 @@ 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`);
@@ -1060,11 +3114,17 @@ var WhisperContext = class _WhisperContext {
 var index_default = WhisperContext;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LangChainMemoryAdapter,
+  LangGraphCheckpointAdapter,
   Whisper,
   WhisperAgentMiddleware,
+  WhisperClient,
   WhisperContext,
   WhisperDefault,
   WhisperError,
+  WhisperRuntimeClient,
   createAgentMiddleware,
+  createLangChainMemoryAdapter,
+  createLangGraphCheckpointAdapter,
   memoryGraphToMermaid
 });