@maximem/synap-js-sdk 0.4.0 → 0.4.2

package/dist/index.cjs

@@ -32,7 +32,7 @@ var _chunkHR5Y3KXScjs = require('./chunk-HR5Y3KXS.cjs');
 
 
 
-var _chunkNIDPTBNCcjs = require('./chunk-NIDPTBNC.cjs');
+var _chunkRB57I2IQcjs = require('./chunk-RB57I2IQ.cjs');
 
 
 var _chunkZKOJDUN4cjs = require('./chunk-ZKOJDUN4.cjs');
@@ -525,10 +525,19 @@ function buildFetchRequest(scope, options) {
   }
   return { endpoint: ENDPOINT_BY_SCOPE[scope], body };
 }
-async function fetchContext(transport, scope, options = {}) {
+async function fetchContext(transport, scope, options = {}, hooks = {}) {
+  const startedAt = Date.now();
+  const anticipated = _nullishCoalesce(_optionalChain([hooks, 'access', _26 => _26.beforeFetch, 'optionalCall', _27 => _27(scope, options)]), () => ( null));
+  if (anticipated !== null) {
+    _optionalChain([hooks, 'access', _28 => _28.onServedFromCache, 'optionalCall', _29 => _29(scope, options, anticipated)]);
+    _optionalChain([hooks, 'access', _30 => _30.onAssembled, 'optionalCall', _31 => _31(scope, options, anticipated.response, startedAt)]);
+    return anticipated.response;
+  }
   const { endpoint, body } = buildFetchRequest(scope, options);
   const result = await transport.request(endpoint, { body });
-  return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _26 => _26["context"]]), () => ( {}));
+  const response = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _32 => _32["context"]]), () => ( {}));
+  _optionalChain([hooks, 'access', _33 => _33.onAssembled, 'optionalCall', _34 => _34(scope, options, response, startedAt)]);
+  return response;
 }
 
 // src/context/normalize.ts
@@ -887,14 +896,14 @@ function sleep2(ms, signal) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      _optionalChain([signal, 'optionalAccess', _27 => _27.removeEventListener, 'call', _28 => _28("abort", onAbort)]);
+      _optionalChain([signal, 'optionalAccess', _35 => _35.removeEventListener, 'call', _36 => _36("abort", onAbort)]);
       resolve();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
-      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _29 => _29.reason]), () => ( new Error("Aborted"))));
+      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _37 => _37.reason]), () => ( new Error("Aborted"))));
     }
-    _optionalChain([signal, 'optionalAccess', _30 => _30.addEventListener, 'call', _31 => _31("abort", onAbort, { once: true })]);
+    _optionalChain([signal, 'optionalAccess', _38 => _38.addEventListener, 'call', _39 => _39("abort", onAbort, { once: true })]);
   });
 }
 
@@ -1031,6 +1040,8 @@ var CompactionSubscribers = class {
   }
 };
 function createConversationNamespace(transport, subscribers = new CompactionSubscribers(), onWrite = () => {
+}, onTurn = () => {
+}, onFetched = () => {
 }) {
   const convId = (v) => {
     const id = typeof v === "string" ? v : _nullishCoalesce(v.conversation_id, () => ( v.conversationId));
@@ -1042,6 +1053,12 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
     async record_message(options) {
       const body = buildRecordMessageBody(options);
       const result = await transport.request("conversations_messages", { body });
+      onTurn({
+        conversationId: String(_nullishCoalesce(body["conversation_id"], () => ( ""))),
+        role: String(_nullishCoalesce(body["role"], () => ( "user"))),
+        content: String(_nullishCoalesce(body["content"], () => ( ""))),
+        timestamp: body["timestamp"]
+      });
       onWrite({
         userId: body["user_id"],
         customerId: body["customer_id"]
@@ -1056,6 +1073,14 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
       const result = await transport.request("conversations_messages_batch", {
         body: { messages: bodies }
       });
+      for (const body of bodies) {
+        onTurn({
+          conversationId: String(_nullishCoalesce(body["conversation_id"], () => ( ""))),
+          role: String(_nullishCoalesce(body["role"], () => ( "user"))),
+          content: String(_nullishCoalesce(body["content"], () => ( ""))),
+          timestamp: body["timestamp"]
+        });
+      }
       for (const body of bodies) {
         onWrite({
           userId: body["user_id"],
@@ -1075,10 +1100,15 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
     },
     context: {
       async fetch(options = {}) {
-        validateConversationId(
-          _nullishCoalesce(options.conversation_id, () => ( options.conversationId))
+        const id = _nullishCoalesce(options.conversation_id, () => ( options.conversationId));
+        validateConversationId(id);
+        const response = await fetchContext(transport, "conversation", options);
+        onFetched(
+          response,
+          id,
+          _nullishCoalesce(options.user_id, () => ( options.userId))
         );
-        return fetchContext(transport, "conversation", options);
+        return response;
       },
       get_context_for_prompt: async (options = {}) => {
         const id = convId(options);
@@ -1086,7 +1116,7 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
           pathParams: { conversation_id: id },
           query: { style: _nullishCoalesce(options.style, () => ( "structured")) }
         });
-        return _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _32 => _32["context_for_prompt"]]), () => ( result)), () => ( {}));
+        return _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _40 => _40["context_for_prompt"]]), () => ( result)), () => ( {}));
       },
       async compact(options) {
         return transport.request("conversations_compact", { body: buildCompactBody(options) });
@@ -1134,7 +1164,7 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
 }
 
 // src/user/interface.ts
-function createUserNamespace(transport) {
+function createUserNamespace(transport, hooks = {}) {
   return {
     async get_profile(options) {
       const userId = typeof options === "string" ? options : _nullishCoalesce(options.user_id, () => ( options.userId));
@@ -1148,7 +1178,7 @@ function createUserNamespace(transport) {
       });
     },
     context: { async fetch(options = {}) {
-      return fetchContext(transport, "user", options);
+      return fetchContext(transport, "user", options, hooks);
     } }
   };
 }
@@ -1208,16 +1238,27 @@ function envPort() {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 function envTls() {
-  const raw = _chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_GRPC_USE_TLS");
+  const raw = _nullishCoalesce(_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_GRPC_USE_TLS"), () => ( _chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_GRPC_TLS")));
   if (raw === void 0 || raw === "") return void 0;
   return !["0", "false", "no", "off"].includes(raw.trim().toLowerCase());
 }
-function createInstanceNamespace(credentials, cache) {
+function createInstanceNamespace(credentials, cache, onTurn) {
   let client = null;
   let dispatchCompaction = null;
+  let applyCompaction = null;
   const internals = {
     onCompactionUpdate(conversationId, bundle) {
-      _optionalChain([dispatchCompaction, 'optionalCall', _33 => _33(conversationId, bundle)]);
+      _optionalChain([applyCompaction, 'optionalCall', _41 => _41(bundle)]);
+      _optionalChain([dispatchCompaction, 'optionalCall', _42 => _42(conversationId, bundle)]);
+    },
+    setCompactionApplier(apply) {
+      applyCompaction = apply;
+    },
+    sendContextUsed(event) {
+      _optionalChain([client, 'optionalAccess', _43 => _43.sendContextUsed, 'call', _44 => _44(event)]);
+    },
+    sendContextAssembled(event) {
+      _optionalChain([client, 'optionalAccess', _45 => _45.sendContextAssembled, 'call', _46 => _46(event)]);
     },
     setCompactionDispatcher(dispatch) {
       dispatchCompaction = dispatch;
@@ -1247,9 +1288,9 @@ function createInstanceNamespace(credentials, cache) {
         onStateChange: (state) => {
           if (state === "reconnecting") {
             reconnectAttempts += 1;
-            _optionalChain([onReconnect, 'optionalCall', _34 => _34(reconnectAttempts)]);
+            _optionalChain([onReconnect, 'optionalCall', _47 => _47(reconnectAttempts)]);
           } else if (state === "disconnected") {
-            _optionalChain([onDisconnect, 'optionalCall', _35 => _35("stream disconnected")]);
+            _optionalChain([onDisconnect, 'optionalCall', _48 => _48("stream disconnected")]);
           }
         }
       });
@@ -1258,7 +1299,7 @@ function createInstanceNamespace(credentials, cache) {
       } catch (error) {
         if (error instanceof _chunkHR5Y3KXScjs.SynapError) throw error;
         throw new (0, _chunkHR5Y3KXScjs.SynapError)(
-          `Could not open the Synap anticipation stream: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _36 => _36.message]), () => ( String(error)))}`,
+          `Could not open the Synap anticipation stream: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _49 => _49.message]), () => ( String(error)))}`,
           { cause: error }
         );
       }
@@ -1275,6 +1316,12 @@ function createInstanceNamespace(credentials, cache) {
       if (options.content === void 0) {
         throw new (0, _chunkHR5Y3KXScjs.ListeningNotActiveError)("content is required");
       }
+      const conversationId = _nullishCoalesce(_nullishCoalesce(options.conversation_id, () => ( options.conversationId)), () => ( ""));
+      _optionalChain([onTurn, 'optionalCall', _50 => _50({
+        conversationId,
+        role: _nullishCoalesce(options.role, () => ( "user")),
+        content: options.content
+      })]);
       client.sendConversationEvent({
         event_type: _nullishCoalesce(_nullishCoalesce(options.event_type, () => ( options.eventType)), () => ( "user_message")),
         content: options.content,
@@ -1315,6 +1362,403 @@ function createInstanceNamespace(credentials, cache) {
 // src/version.ts
 var SDK_VERSION = "1.0.0-beta.0";
 
+// src/registry.ts
+var instances = /* @__PURE__ */ new Map();
+function buildRegistryKey(instanceId, apiKey) {
+  if (instanceId) return instanceId;
+  const key = _nullishCoalesce(apiKey, () => ( ""));
+  if (!key) return "";
+  return `apikey:${digest(key)}`;
+}
+function digest(value) {
+  const PRIME = 1099511628211n;
+  const MASK = 0xffffffffffffffffn;
+  let hash = 14695981039346656037n;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= BigInt(value.charCodeAt(i));
+    hash = hash * PRIME & MASK;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function get(key) {
+  return instances.get(key);
+}
+function registerIfAbsent(key, client) {
+  const existing = instances.get(key);
+  if (existing !== void 0) return existing;
+  instances.set(key, client);
+  return void 0;
+}
+function aliasIfAbsent(key, client) {
+  if (!key || instances.has(key)) return false;
+  instances.set(key, client);
+  return true;
+}
+function unregisterIfOwner(key, client) {
+  if (instances.get(key) === client) instances.delete(key);
+}
+
+// src/cache/short-term-store.ts
+var DEFAULT_MAX_CONVERSATIONS = 100;
+var DEFAULT_MAX_AGE_MS = 12 * 60 * 60 * 1e3;
+function parseIso(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (value instanceof Date) return value.getTime();
+  if (typeof value !== "string") return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function isAfter(turnTimestamp, cutoffMs) {
+  const parsed = parseIso(turnTimestamp);
+  if (parsed === null) return true;
+  return parsed > cutoffMs;
+}
+var ShortTermStore = class {
+  // Insertion order IS the LRU order: re-inserting on touch moves an entry to
+  // the end, so the first key Map yields is the least recently used.
+  #entries = /* @__PURE__ */ new Map();
+  #maxConversations;
+  #maxAgeMs;
+  #now;
+  constructor(options = {}) {
+    this.#maxConversations = _nullishCoalesce(options.maxConversations, () => ( DEFAULT_MAX_CONVERSATIONS));
+    this.#maxAgeMs = _nullishCoalesce(options.maxAgeMs, () => ( DEFAULT_MAX_AGE_MS));
+    this.#now = _nullishCoalesce(options.now, () => ( (() => Date.now())));
+  }
+  /** The entry, or null. Age-evicts on read, as Python does. */
+  get(conversationId) {
+    if (!conversationId) return null;
+    const entry = this.#entries.get(conversationId);
+    if (entry === void 0) return null;
+    if (this.#now() - entry.lastActivityAt > this.#maxAgeMs) {
+      this.#entries.delete(conversationId);
+      return null;
+    }
+    this.#touch(conversationId, entry);
+    return entry;
+  }
+  has(conversationId) {
+    return this.get(conversationId) !== null;
+  }
+  get size() {
+    return this.#entries.size;
+  }
+  /**
+   * Append a raw turn.
+   *
+   * Called from `record_message` and the stream's `send_message`. When no entry
+   * exists yet (the first turn, before any compaction has arrived) a fresh one
+   * is created with an empty summary; the next `compaction_update` fills the
+   * summary fields in and prunes the turns it covers.
+   */
+  appendTurn(conversationId, role, content, timestamp) {
+    if (!conversationId) return;
+    const stamp = _nullishCoalesce(timestamp, () => ( new Date(this.#now()).toISOString()));
+    const entry = _nullishCoalesce(this.#entries.get(conversationId), () => ( this.#blank(conversationId)));
+    entry.recentTurns.push({ role, content, timestamp: stamp });
+    entry.lastActivityAt = _nullishCoalesce(parseIso(stamp), () => ( this.#now()));
+    this.#touch(conversationId, entry);
+    this.#evict();
+  }
+  /**
+   * Apply a `compaction_update` bundle.
+   *
+   * Replaces the summary fields from the bundle's `conversation_context` and
+   * prunes locally buffered turns at or before its `end_timestamp`. Turns that
+   * arrived DURING the compaction window are kept by design: the server has not
+   * seen them yet, which is the whole reason the local tail exists.
+   */
+  applyCompaction(bundle) {
+    if (typeof bundle !== "object" || bundle === null) return;
+    const cc = _nullishCoalesce(bundle["conversation_context"], () => ( {}));
+    const conversationId = String(
+      _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(cc["conversation_id"], () => ( bundle["anticipation_conversation_id"])), () => ( bundle["conversation_id"])), () => ( ""))
+    );
+    if (!conversationId) return;
+    const endTs = parseIso(_nullishCoalesce(cc["end_timestamp"], () => ( cc["compacted_at"])));
+    const entry = _nullishCoalesce(this.#entries.get(conversationId), () => ( this.#blank(conversationId)));
+    entry.summary = cc["summary"] || entry.summary;
+    entry.factualParagraph = cc["factual_paragraph"] || entry.factualParagraph;
+    entry.conversationalParagraph = cc["conversational_paragraph"] || entry.conversationalParagraph;
+    entry.currentState = { ..._nullishCoalesce(cc["current_state"], () => ( {})) };
+    entry.keyExtractions = { ..._nullishCoalesce(cc["key_extractions"], () => ( {})) };
+    entry.compactionId = cc["compaction_id"] || entry.compactionId;
+    entry.compactedAt = cc["compacted_at"] || entry.compactedAt;
+    entry.endTimestamp = cc["end_timestamp"] || entry.endTimestamp;
+    if (endTs !== null && entry.recentTurns.length > 0) {
+      entry.recentTurns = entry.recentTurns.filter((t) => isAfter(t.timestamp, endTs));
+    }
+    entry.lastActivityAt = this.#now();
+    this.#touch(conversationId, entry);
+    this.#evict();
+  }
+  invalidate(conversationId) {
+    this.#entries.delete(conversationId);
+  }
+  clear() {
+    this.#entries.clear();
+  }
+  #blank(conversationId) {
+    return {
+      conversationId,
+      summary: null,
+      factualParagraph: null,
+      conversationalParagraph: null,
+      currentState: {},
+      keyExtractions: {},
+      compactionId: null,
+      compactedAt: null,
+      endTimestamp: null,
+      recentTurns: [],
+      lastActivityAt: this.#now()
+    };
+  }
+  /** Re-insert so this key becomes the most recently used. */
+  #touch(conversationId, entry) {
+    this.#entries.delete(conversationId);
+    this.#entries.set(conversationId, entry);
+  }
+  #evict() {
+    while (this.#entries.size > this.#maxConversations) {
+      const oldest = this.#entries.keys().next();
+      if (oldest.done === true) break;
+      this.#entries.delete(oldest.value);
+    }
+  }
+};
+
+// src/context/overlay.ts
+var MAX_TURNS = 20;
+var TOKEN_BUDGET = 2e3;
+function verbatimOverlayEnabled() {
+  const raw = (_nullishCoalesce(_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_ST_VERBATIM_OVERLAY"), () => ( ""))).trim().toLowerCase();
+  if (["0", "false", "no", "off"].includes(raw)) return false;
+  if (["1", "true", "yes", "on"].includes(raw)) return true;
+  return true;
+}
+function estimateTokens(turn) {
+  return Math.max(1, Math.floor(String(_nullishCoalesce(turn.content, () => ( ""))).length / 4));
+}
+function budgetRecentTurns(turns) {
+  const windowed = turns.slice(-MAX_TURNS);
+  let total = windowed.reduce((n2, t) => n2 + estimateTokens(t), 0);
+  while (windowed.length > 0 && total > TOKEN_BUDGET) {
+    const dropped = windowed.shift();
+    total -= estimateTokens(dropped);
+  }
+  return windowed;
+}
+function overlayLocalRecentTurns(response, store, conversationId) {
+  if (conversationId === void 0 || conversationId === "") return;
+  try {
+    const entry = store.get(conversationId);
+    if (entry === null) return;
+    const existing = _nullishCoalesce(response.conversation_context, () => ( null));
+    if (existing !== null && !verbatimOverlayEnabled()) return;
+    const localTurns = budgetRecentTurns(entry.recentTurns);
+    const serverField = (name) => existing === null ? void 0 : existing[name];
+    const orLocal = (name, local) => {
+      const value = serverField(name);
+      if (value === void 0 || value === null || value === "") return local;
+      if (typeof value === "object" && Object.keys(value).length === 0) return local;
+      return value;
+    };
+    response.conversation_context = {
+      summary: orLocal("summary", entry.summary),
+      current_state: orLocal("current_state", { ...entry.currentState }),
+      key_extractions: orLocal("key_extractions", { ...entry.keyExtractions }),
+      recent_turns: localTurns,
+      compaction_id: orLocal("compaction_id", entry.compactionId),
+      compacted_at: orLocal("compacted_at", entry.compactedAt),
+      conversation_id: conversationId
+    };
+  } catch (e5) {
+  }
+}
+
+// src/context/user-summary.ts
+var USER_SUMMARY_INTERVAL = 5;
+var MAX_SUMMARY_ITEMS = 3;
+var COLLECTIONS = ["facts", "preferences", "episodes", "emotions", "temporal_events"];
+var TurnCounter = class {
+  #counts = /* @__PURE__ */ new Map();
+  /** Increment and return the new count. Python buckets a missing id under `_global`. */
+  increment(conversationId) {
+    const key = conversationId !== void 0 && conversationId !== "" ? conversationId : "_global";
+    const next = (_nullishCoalesce(this.#counts.get(key), () => ( 0))) + 1;
+    this.#counts.set(key, next);
+    return next;
+  }
+  /**
+   * True on every Nth turn, and never on the first.
+   *
+   * Python: `count > 0 and count % interval == 0`. Turn 5 injects, turn 1 does
+   * not, which matters because the first turn is usually the one that just
+   * triggered a fresh retrieval anyway.
+   */
+  shouldInject(conversationId) {
+    const key = conversationId !== void 0 && conversationId !== "" ? conversationId : "_global";
+    const count = _nullishCoalesce(this.#counts.get(key), () => ( 0));
+    return count > 0 && count % USER_SUMMARY_INTERVAL === 0;
+  }
+  clear() {
+    this.#counts.clear();
+  }
+};
+function itemId(item) {
+  return String(_nullishCoalesce(_nullishCoalesce(item["item_id"], () => ( item["id"])), () => ( "")));
+}
+function pick2(item, ...names) {
+  for (const name of names) {
+    const value = item[name];
+    if (value !== void 0 && value !== null) return value;
+  }
+  return void 0;
+}
+function normalise(item) {
+  const content = _nullishCoalesce(pick2(item, "content"), () => ( ""));
+  const confidence = _nullishCoalesce(pick2(item, "confidence"), () => ( 0));
+  const extractedAt = _nullishCoalesce(pick2(item, "extracted_at", "created_at"), () => ( null));
+  return {
+    id: itemId(item),
+    content: String(content),
+    confidence: Number(confidence),
+    source: String(_nullishCoalesce(pick2(item, "source"), () => ( ""))),
+    category: String(_nullishCoalesce(pick2(item, "context_type", "category"), () => ( ""))),
+    emotion_type: String(_nullishCoalesce(pick2(item, "context_type", "emotion_type"), () => ( ""))),
+    strength: Number(_nullishCoalesce(pick2(item, "strength", "confidence"), () => ( 0))),
+    summary: String(_nullishCoalesce(pick2(item, "summary", "content"), () => ( ""))),
+    significance: Number(_nullishCoalesce(pick2(item, "significance", "confidence"), () => ( 0))),
+    intensity: Number(_nullishCoalesce(pick2(item, "intensity", "confidence"), () => ( 0))),
+    context: String(_nullishCoalesce(pick2(item, "context", "content"), () => ( ""))),
+    participants: _nullishCoalesce(pick2(item, "participants"), () => ( [])),
+    extracted_at: extractedAt,
+    occurred_at: _nullishCoalesce(pick2(item, "occurred_at", "extracted_at", "created_at"), () => ( null)),
+    detected_at: _nullishCoalesce(pick2(item, "detected_at", "extracted_at", "created_at"), () => ( null)),
+    metadata: _nullishCoalesce(pick2(item, "metadata"), () => ( {})),
+    event_date: _nullishCoalesce(pick2(item, "event_date"), () => ( null)),
+    valid_until: _nullishCoalesce(pick2(item, "valid_until"), () => ( null)),
+    temporal_category: _nullishCoalesce(pick2(item, "temporal_category"), () => ( null)),
+    temporal_confidence: Number(_nullishCoalesce(pick2(item, "temporal_confidence"), () => ( 0)))
+  };
+}
+function mergeUserSummary(response, bundle) {
+  const itemsByType = _nullishCoalesce(bundle["items_by_type"], () => ( {}));
+  for (const collection of COLLECTIONS) {
+    const items = itemsByType[collection];
+    if (!Array.isArray(items)) continue;
+    const existing = _nullishCoalesce(response[collection], () => ( []));
+    const existingIds = new Set(existing.map((i) => String(_nullishCoalesce(_nullishCoalesce(i.id, () => ( i.item_id)), () => ( "")))));
+    const fresh = items.filter((i) => typeof i === "object" && i !== null && !existingIds.has(itemId(i))).slice(0, MAX_SUMMARY_ITEMS).map(normalise);
+    if (fresh.length === 0) continue;
+    response[collection] = [...existing, ...fresh];
+  }
+  return response;
+}
+
+// src/context/anticipated.ts
+function scopeLookupParams(scope, params) {
+  const { searchQuery, entityId, customerId, clientId, conversationId } = params;
+  switch (scope) {
+    case "conversation":
+      return { searchQuery, entityId, customerId, clientId, conversationId };
+    case "user":
+      return { searchQuery, entityId, customerId, clientId };
+    case "customer":
+      return { searchQuery, entityId: null, customerId, clientId };
+    case "client":
+      return { searchQuery, entityId: null, customerId: null, clientId };
+  }
+}
+function buildAnticipationResponse(hit) {
+  const response = {};
+  for (const [type, items] of Object.entries(hit.itemsByType)) {
+    response[type] = items;
+  }
+  response.metadata = {
+    source: "anticipation",
+    ttl_seconds: 0,
+    cache_hit: true,
+    retrieved_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return response;
+}
+function servedItemIds(hit) {
+  const ids = [];
+  for (const items of Object.values(hit.itemsByType)) {
+    for (const item of items) {
+      const id = _nullishCoalesce(item.item_id, () => ( item["id"]));
+      if (typeof id === "string" && id !== "") ids.push(id);
+    }
+  }
+  return ids;
+}
+function tryServeFromCache(cache, scope, params, maxItems) {
+  try {
+    const scoped = scopeLookupParams(scope, params);
+    const hit = cache.lookup({
+      searchQuery: _nullishCoalesce(scoped.searchQuery, () => ( null)),
+      entityId: _nullishCoalesce(scoped.entityId, () => ( null)),
+      customerId: _nullishCoalesce(scoped.customerId, () => ( null)),
+      clientId: _nullishCoalesce(scoped.clientId, () => ( null)),
+      conversationId: _nullishCoalesce(scoped.conversationId, () => ( null)),
+      maxItems
+    });
+    if (hit === null) return { response: null, hit: null };
+    return { response: buildAnticipationResponse(hit), hit };
+  } catch (e6) {
+    return { response: null, hit: null };
+  }
+}
+
+// src/context/assembled.ts
+var COLLECTIONS2 = ["facts", "preferences", "episodes", "emotions", "temporal_events"];
+function finalItemIds(response) {
+  const ids = [];
+  for (const collection of COLLECTIONS2) {
+    const items = response[collection];
+    if (!Array.isArray(items)) continue;
+    for (const item of items) {
+      const id = _nullishCoalesce(item["id"], () => ( item["item_id"]));
+      if (typeof id === "string" && id !== "") ids.push(id);
+    }
+  }
+  return ids;
+}
+function resolveSource(response, override) {
+  const metadata = _nullishCoalesce(response.metadata, () => ( {}));
+  let source = _nullishCoalesce(_nullishCoalesce(override, () => ( String(_nullishCoalesce(metadata["source"], () => ( ""))))), () => ( ""));
+  if (source === "") source = "cloud";
+  if (source === "cache") source = "http_cache";
+  const impliesHit = ["anticipation", "anticipation_cache", "http_cache", "sdk_authoritative"];
+  const cacheHit = impliesHit.includes(source) ? true : Boolean(metadata["cache_hit"]);
+  return { source, cacheHit };
+}
+function buildAssembledEvent(params) {
+  const { response } = params;
+  const { source, cacheHit } = resolveSource(response, params.sourceOverride);
+  const conversationContext = _nullishCoalesce(response.conversation_context, () => ( {}));
+  const recentTurns = conversationContext["recent_turns"];
+  const metadata = _nullishCoalesce(response.metadata, () => ( {}));
+  return {
+    correlation_id: params.correlationId,
+    conversation_id: _nullishCoalesce(params.conversationId, () => ( "")),
+    user_id: _nullishCoalesce(params.userId, () => ( "")),
+    customer_id: _nullishCoalesce(params.customerId, () => ( "")),
+    final_item_ids: finalItemIds(response),
+    final_total_tokens: Number(_nullishCoalesce(metadata["total_tokens"], () => ( 0))),
+    compaction_id: String(_nullishCoalesce(conversationContext["compaction_id"], () => ( ""))),
+    recent_turn_count: Array.isArray(recentTurns) ? recentTurns.length : 0,
+    compaction_end_timestamp: String(
+      _nullishCoalesce(_nullishCoalesce(conversationContext["end_timestamp"], () => ( conversationContext["compacted_at"])), () => ( ""))
+    ),
+    assembly_source: source,
+    assembly_duration_ms: Math.max(0, Date.now() - params.startedAt),
+    cache_hit: cacheHit,
+    sdk_version: params.sdkVersion
+  };
+}
+
 // src/context/unified.ts
 var ITEM_COLLECTIONS = [
   "facts",
@@ -1323,7 +1767,7 @@ var ITEM_COLLECTIONS = [
   "emotions",
   "temporal_events"
 ];
-function itemId(item) {
+function itemId2(item) {
   const id = _nullishCoalesce(item.id, () => ( item.item_id));
   return typeof id === "string" && id !== "" ? id : void 0;
 }
@@ -1359,7 +1803,7 @@ function mergeScopeResults(scopeResults) {
       const items = response[collection];
       if (!Array.isArray(items)) continue;
       for (const item of items) {
-        const id = itemId(item);
+        const id = itemId2(item);
         if (id !== void 0) {
           if (seen.has(id)) continue;
           seen.add(id);
@@ -1385,7 +1829,7 @@ function numberOf(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function scopeOf(ctx, item) {
-  const id = itemId(item);
+  const id = itemId2(item);
   return _nullishCoalesce((id !== void 0 ? ctx.scope_map[id] : void 0), () => ( "unknown"));
 }
 function bulletWithExtras(text, extras) {
@@ -1700,6 +2144,11 @@ var SynapClient = class {
   // can still reach it. These two were public and made `client.transport
   // .credentials.apiKey` and the raw cache's `now`/`fire`/`invalidateEntity`
   // reachable, which is exactly what `client.cache` exists to prevent.
+  // Definite-assignment assertions (`!`) because the constructor can RETURN an
+  // existing client from the registry before reaching any of these. TypeScript
+  // cannot follow a constructor return, so it sees a path where the fields are
+  // unassigned. On that path the object is discarded and the incumbent is
+  // handed back instead, so nothing observes them.
   #transport;
   #anticipationCache;
   
@@ -1712,13 +2161,37 @@ var SynapClient = class {
   
   #closed = false;
   #initialized = false;
+  #registryKeys;
   #compactionSubscribers;
+  #shortTerm;
+  #turns;
+  #fetchHooks;
   constructor(options = {}) {
     const credentials = resolveCredentials(options);
+    const resolvedBaseUrl = resolveBaseUrl(options);
     validateInstanceId(credentials.instanceId);
+    const registryKey = buildRegistryKey(credentials.instanceId, credentials.apiKey);
+    if (options._force_new !== true) {
+      const existing = get(registryKey);
+      if (existing !== void 0) {
+        const incumbent = existing.#transport.currentCredentials().apiKey;
+        if (credentials.apiKey && incumbent && credentials.apiKey !== incumbent) {
+          existing.#warn(
+            `Instance ${registryKey} is already running in this process on a different API key. The key passed here is ignored; this client will authenticate as the existing one. Rotating a key this way has no effect. Construct with apiKey and no instanceId to get a client on your own credential.`
+          );
+        }
+        return existing;
+      }
+    }
+    this.#registryKeys = options._force_new === true ? [] : [registryKey];
     this.#transport = new HttpTransport({
       credentials,
-      ...options.baseUrl !== void 0 ? { baseUrl: options.baseUrl } : {},
+      // SYNAP_BASE_URL is honoured, as Python does (sdk.py) and as the 0.3.x
+      // wrapper did. Ignoring it was a wrong-DESTINATION bug rather than a
+      // missing convenience: anyone pointing at a self-hosted or staging
+      // deployment through the environment would silently have started sending
+      // their data to production on upgrade.
+      ...resolvedBaseUrl !== void 0 ? { baseUrl: resolvedBaseUrl } : {},
       ...options.timeouts !== void 0 ? { timeouts: options.timeouts } : {},
       ...options.retryPolicy !== void 0 ? { retryPolicy: options.retryPolicy } : {},
       ...options.keepAlive !== void 0 ? { keepAlive: options.keepAlive } : {},
@@ -1726,11 +2199,42 @@ var SynapClient = class {
       userAgent: `@maximem/synap-js-sdk/${SDK_VERSION}`
     });
     if (options.heartbeat) this.#transport.startHeartbeat();
-    this.#anticipationCache = new (0, _chunkNIDPTBNCcjs.AnticipationCache)();
-    this.user = createUserNamespace(this.#transport);
-    this.customer = { context: { fetch: async (o2 = {}) => fetchContext(this.#transport, "customer", o2) } };
-    this.client = { context: { fetch: async (o2 = {}) => fetchContext(this.#transport, "client", o2) } };
+    this.#anticipationCache = new (0, _chunkRB57I2IQcjs.AnticipationCache)();
+    this.#fetchHooks = {
+      beforeFetch: (scope, options2) => {
+        const o2 = options2;
+        const attempt = tryServeFromCache(
+          this.#anticipationCache,
+          scope,
+          {
+            searchQuery: _nullishCoalesce(o2["search_query"], () => ( o2["searchQuery"])),
+            entityId: _nullishCoalesce(o2["user_id"], () => ( o2["userId"])),
+            customerId: _nullishCoalesce(o2["customer_id"], () => ( o2["customerId"])),
+            clientId: this.#transport.currentCredentials().clientId || null,
+            conversationId: _nullishCoalesce(o2["conversation_id"], () => ( o2["conversationId"]))
+          },
+          Number(_nullishCoalesce(_nullishCoalesce(o2["max_results"], () => ( o2["maxResults"])), () => ( 10)))
+        );
+        if (attempt.response === null || attempt.hit === null) return null;
+        return {
+          response: attempt.response,
+          servedItemIds: servedItemIds(attempt.hit),
+          bundleId: _nullishCoalesce(attempt.hit.bundleIds[0], () => ( ""))
+        };
+      },
+      onAssembled: (scope, options2, response, startedAt) => {
+        this.#emitContextAssembled(scope, options2, response, startedAt);
+      },
+      onServedFromCache: (_scope, options2, served) => {
+        this.#emitContextUsed(options2, _scope, served);
+      }
+    };
+    this.user = createUserNamespace(this.#transport, this.#fetchHooks);
+    this.customer = { context: { fetch: async (o2 = {}) => fetchContext(this.#transport, "customer", o2, this.#fetchHooks) } };
+    this.client = { context: { fetch: async (o2 = {}) => fetchContext(this.#transport, "client", o2, this.#fetchHooks) } };
     this.#compactionSubscribers = new CompactionSubscribers();
+    this.#shortTerm = new ShortTermStore();
+    this.#turns = new TurnCounter();
     this.conversation = createConversationNamespace(
       this.#transport,
       this.#compactionSubscribers,
@@ -1743,6 +2247,15 @@ var SynapClient = class {
         for (const id of /* @__PURE__ */ new Set([userId, customerId])) {
           if (id) this.#anticipationCache.invalidateEntity(id);
         }
+      },
+      // Buffer the turn locally so the next fetch sees it, ahead of the server
+      // having persisted and compacted it.
+      ({ conversationId, role, content, timestamp }) => {
+        this.#shortTerm.appendTurn(conversationId, role, content, timestamp);
+      },
+      (response, conversationId, userId) => {
+        overlayLocalRecentTurns(response, this.#shortTerm, conversationId);
+        this.#injectUserSummary(response, conversationId, userId);
       }
     );
     this.memories = createMemoriesInterface(this.#transport);
@@ -1750,8 +2263,18 @@ var SynapClient = class {
     this.cache = createCacheNamespace(this.#anticipationCache);
     this.instance = createInstanceNamespace(
       () => this.#transport.currentCredentials(),
-      this.#anticipationCache
+      this.#anticipationCache,
+      ({ conversationId, role, content }) => {
+        this.#shortTerm.appendTurn(conversationId, role, content);
+      }
     );
+    this.instance._internal.setCompactionApplier((bundle) => {
+      this.#shortTerm.applyCompaction(bundle);
+    });
+    if (options._force_new !== true) {
+      const incumbent = registerIfAbsent(registryKey, this);
+      if (incumbent !== void 0) return incumbent;
+    }
     this.instance._internal.setCompactionDispatcher((conversationId, bundle) => {
       this.#compactionSubscribers.dispatch(conversationId, bundle, (error) => {
         this.#warn(`compaction subscriber threw: ${String(error)}`);
@@ -1789,10 +2312,10 @@ var SynapClient = class {
     }
     const context = await fetchContext(this.#transport, "user", {
       user_id: userId,
-      ...pick2(options, "customer_id", "customerId") !== void 0 ? { customer_id: pick2(options, "customer_id", "customerId") } : {},
-      ...pick2(options, "conversation_id", "conversationId") !== void 0 ? { conversation_id: pick2(options, "conversation_id", "conversationId") } : {},
+      ...pick3(options, "customer_id", "customerId") !== void 0 ? { customer_id: pick3(options, "customer_id", "customerId") } : {},
+      ...pick3(options, "conversation_id", "conversationId") !== void 0 ? { conversation_id: pick3(options, "conversation_id", "conversationId") } : {},
       search_query: [options.query],
-      max_results: _nullishCoalesce(pick2(options, "max_results", "maxResults"), () => ( 10)),
+      max_results: _nullishCoalesce(pick3(options, "max_results", "maxResults"), () => ( 10)),
       types: _nullishCoalesce(options.types, () => ( ["all"])),
       ...options.mode !== void 0 ? { mode: options.mode } : {}
     });
@@ -1809,10 +2332,10 @@ var SynapClient = class {
     if (!userId) throw new (0, _chunkHR5Y3KXScjs.InvalidInputError)("user_id is required");
     const context = await fetchContext(this.#transport, "user", {
       user_id: userId,
-      ...pick2(options, "customer_id", "customerId") !== void 0 ? { customer_id: pick2(options, "customer_id", "customerId") } : {},
-      ...pick2(options, "conversation_id", "conversationId") !== void 0 ? { conversation_id: pick2(options, "conversation_id", "conversationId") } : {},
+      ...pick3(options, "customer_id", "customerId") !== void 0 ? { customer_id: pick3(options, "customer_id", "customerId") } : {},
+      ...pick3(options, "conversation_id", "conversationId") !== void 0 ? { conversation_id: pick3(options, "conversation_id", "conversationId") } : {},
       search_query: [],
-      max_results: _nullishCoalesce(pick2(options, "max_results", "maxResults"), () => ( 100)),
+      max_results: _nullishCoalesce(pick3(options, "max_results", "maxResults"), () => ( 100)),
       types: _nullishCoalesce(options.types, () => ( ["all"])),
       ...options.mode !== void 0 ? { mode: options.mode } : {}
     });
@@ -1858,7 +2381,12 @@ var SynapClient = class {
         ...resolvedClientId !== "" && credentials.clientId === "" ? { clientId: resolvedClientId } : {},
         ...resolvedInstanceId !== "" && credentials.instanceId === "" ? { instanceId: resolvedInstanceId } : {}
       });
-    } catch (e5) {
+      if (resolvedInstanceId !== "" && this.#registryKeys.length > 0) {
+        if (aliasIfAbsent(resolvedInstanceId, this)) {
+          this.#registryKeys.push(resolvedInstanceId);
+        }
+      }
+    } catch (e7) {
     }
   }
   /**
@@ -1994,12 +2522,15 @@ var SynapClient = class {
       this.#warn(`Scope '${label}' fetch failed in unified fetch (non-fatal): ${String(result.reason)}`);
     }
     const merged = mergeScopeResults(successful);
+    for (const [, response] of successful) {
+      overlayLocalRecentTurns(response, this.#shortTerm, conversationId);
+    }
     if (includeConversationContext && conversationId !== void 0 && conversationId !== "") {
       try {
         merged.conversation_context = await this.conversation.context.get_context_for_prompt({
           conversation_id: conversationId
         });
-      } catch (e6) {
+      } catch (e8) {
       }
     }
     merged.formatted_context = formatForPrompt(merged, {
@@ -2026,6 +2557,69 @@ var SynapClient = class {
   anticipation_cache_snapshot() {
     return this.#anticipationCache.snapshot();
   }
+  /**
+   * Report a locally served fetch back to the server.
+   *
+   * Only while listening: the event rides the Listen stream, and there is
+   * nowhere to put it otherwise. Never throws, because a telemetry failure
+   * must not fail a retrieval that already succeeded.
+   */
+  #emitContextUsed(options, scope, served) {
+    try {
+      if (!this.instance.is_listening) return;
+      this.instance._internal.sendContextUsed({
+        bundle_id: served.bundleId,
+        conversation_id: String(_nullishCoalesce(_nullishCoalesce(options["conversation_id"], () => ( options["conversationId"])), () => ( ""))),
+        user_id: String(_nullishCoalesce(_nullishCoalesce(options["user_id"], () => ( options["userId"])), () => ( ""))),
+        customer_id: String(_nullishCoalesce(_nullishCoalesce(options["customer_id"], () => ( options["customerId"])), () => ( ""))),
+        served_item_ids: served.servedItemIds,
+        scope,
+        source_bundle_ids: served.bundleId ? [served.bundleId] : [],
+        timestamp_ms: Date.now()
+      });
+    } catch (e9) {
+    }
+  }
+  /**
+   * Report what was actually composed for this turn.
+   *
+   * Fires whether the fetch was served from the cache or the network, because
+   * the audit needs to distinguish them. Like the other stream events it is
+   * fire-and-forget and only goes anywhere while listening.
+   */
+  #emitContextAssembled(scope, options, response, startedAt) {
+    try {
+      if (!this.instance.is_listening) return;
+      this.instance._internal.sendContextAssembled({
+        ...buildAssembledEvent({
+          correlationId: newCorrelationId(),
+          response,
+          conversationId: _nullishCoalesce(options["conversation_id"], () => ( options["conversationId"])),
+          userId: _nullishCoalesce(options["user_id"], () => ( options["userId"])),
+          customerId: _nullishCoalesce(options["customer_id"], () => ( options["customerId"])),
+          startedAt,
+          sdkVersion: SDK_VERSION
+        }),
+        scope
+      });
+    } catch (e10) {
+    }
+  }
+  /**
+   * Fold a cached user summary in, every Nth turn.
+   *
+   * Only when the caller supplied a user_id. Without one the summary lookup
+   * cannot be scoped, and an unscoped lookup is how user A's summary ends up in
+   * user B's response.
+   */
+  #injectUserSummary(response, conversationId, userId) {
+    this.#turns.increment(conversationId);
+    if (userId === void 0 || userId === "") return;
+    if (!this.#turns.shouldInject(conversationId)) return;
+    const summary = this.#anticipationCache.lookupUserSummary(userId);
+    if (summary === null) return;
+    mergeUserSummary(response, summary);
+  }
   /** Python logs via `logger.warning`; here it is one overridable seam. */
   #warn(message) {
     console.warn(`[synap] ${message}`);
@@ -2034,16 +2628,24 @@ var SynapClient = class {
   async shutdown() {
     if (this.#closed) return;
     this.#closed = true;
+    this.#shortTerm.clear();
+    this.#turns.clear();
+    for (const key of this.#registryKeys) unregisterIfOwner(key, this);
     await this.instance.stop_listening();
     this.#compactionSubscribers.removeAll();
     this.#transport.close();
     this.#anticipationCache.clear();
   }
 };
-function pick2(o2, snake, camel) {
+function pick3(o2, snake, camel) {
   const a = o2[snake];
   return a !== void 0 ? a : o2[camel];
 }
+function resolveBaseUrl(options) {
+  if (options.baseUrl !== void 0) return options.baseUrl;
+  const fromEnv = _optionalChain([_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_BASE_URL"), 'optionalAccess', _51 => _51.trim, 'call', _52 => _52()]);
+  return fromEnv !== void 0 && fromEnv !== "" ? fromEnv : void 0;
+}
 function resolveCredentials(options) {
   const apiKey = _nullishCoalesce(options.apiKey, () => ( _chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_API_KEY")));
   if (!apiKey) {
@@ -2107,5 +2709,5 @@ function resolveCredentials(options) {
 
 
 
-exports.ANY_SCOPE = _chunkNIDPTBNCcjs.ANY_SCOPE; exports.AgentUnavailableError = _chunkHR5Y3KXScjs.AgentUnavailableError; exports.AnticipationCache = _chunkNIDPTBNCcjs.AnticipationCache; exports.AuthenticationError = _chunkHR5Y3KXScjs.AuthenticationError; exports.BM25 = _chunkNIDPTBNCcjs.BM25; exports.CONTRACT = _chunkNIDPTBNCcjs.CONTRACT; exports.ConflictError = _chunkHR5Y3KXScjs.ConflictError; exports.ConnectionError = _chunkHR5Y3KXScjs.ConnectionError; exports.ContextNotFoundError = _chunkHR5Y3KXScjs.ContextNotFoundError; exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL; exports.DEFAULT_DOCUMENT_TYPE = DEFAULT_DOCUMENT_TYPE; exports.DEFAULT_INGEST_MODE = DEFAULT_INGEST_MODE; exports.DEFAULT_RETRY_POLICY = DEFAULT_RETRY_POLICY; exports.DEFAULT_TIMEOUTS = DEFAULT_TIMEOUTS; exports.DOCUMENT_TYPES = DOCUMENT_TYPES; exports.ENDPOINTS = ENDPOINTS; exports.HttpTransport = HttpTransport; exports.INGEST_MODES = INGEST_MODES; exports.ITEM_COLLECTIONS = ITEM_COLLECTIONS; exports.InsufficientCreditsError = _chunkHR5Y3KXScjs.InsufficientCreditsError; exports.InvalidConversationIdError = _chunkHR5Y3KXScjs.InvalidConversationIdError; exports.InvalidInputError = _chunkHR5Y3KXScjs.InvalidInputError; exports.InvalidInstanceIdError = _chunkHR5Y3KXScjs.InvalidInstanceIdError; exports.ListeningAlreadyActiveError = _chunkHR5Y3KXScjs.ListeningAlreadyActiveError; exports.ListeningNotActiveError = _chunkHR5Y3KXScjs.ListeningNotActiveError; exports.NetworkTimeoutError = _chunkHR5Y3KXScjs.NetworkTimeoutError; exports.PermanentError = _chunkHR5Y3KXScjs.PermanentError; exports.RateLimitError = _chunkHR5Y3KXScjs.RateLimitError; exports.SDKError = _chunkHR5Y3KXScjs.SDKError; exports.SDK_VERSION = SDK_VERSION; exports.ServiceUnavailableError = _chunkHR5Y3KXScjs.ServiceUnavailableError; exports.SessionExpiredError = _chunkHR5Y3KXScjs.SessionExpiredError; exports.SynapClient = SynapClient; exports.SynapError = _chunkHR5Y3KXScjs.SynapError; exports.SynapPermanentError = _chunkHR5Y3KXScjs.SynapPermanentError; exports.SynapTransientError = _chunkHR5Y3KXScjs.SynapTransientError; exports.THRESHOLDS = _chunkNIDPTBNCcjs.THRESHOLDS; exports.TranscriptConflictError = _chunkHR5Y3KXScjs.TranscriptConflictError; exports.TransientError = _chunkHR5Y3KXScjs.TransientError; exports.flattenContextItems = flattenContextItems; exports.formatForPrompt = formatForPrompt; exports.isOutcomeUnknown = isOutcomeUnknown; exports.isRecallQuery = _chunkNIDPTBNCcjs.isRecallQuery; exports.isSynapError = _chunkHR5Y3KXScjs.isSynapError; exports.mergeScopeResults = mergeScopeResults; exports.resolvePath = resolvePath; exports.shouldRetry = shouldRetry; exports.stem = _chunkNIDPTBNCcjs.stem; exports.tokenize = _chunkNIDPTBNCcjs.tokenize;
+exports.ANY_SCOPE = _chunkRB57I2IQcjs.ANY_SCOPE; exports.AgentUnavailableError = _chunkHR5Y3KXScjs.AgentUnavailableError; exports.AnticipationCache = _chunkRB57I2IQcjs.AnticipationCache; exports.AuthenticationError = _chunkHR5Y3KXScjs.AuthenticationError; exports.BM25 = _chunkRB57I2IQcjs.BM25; exports.CONTRACT = _chunkRB57I2IQcjs.CONTRACT; exports.ConflictError = _chunkHR5Y3KXScjs.ConflictError; exports.ConnectionError = _chunkHR5Y3KXScjs.ConnectionError; exports.ContextNotFoundError = _chunkHR5Y3KXScjs.ContextNotFoundError; exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL; exports.DEFAULT_DOCUMENT_TYPE = DEFAULT_DOCUMENT_TYPE; exports.DEFAULT_INGEST_MODE = DEFAULT_INGEST_MODE; exports.DEFAULT_RETRY_POLICY = DEFAULT_RETRY_POLICY; exports.DEFAULT_TIMEOUTS = DEFAULT_TIMEOUTS; exports.DOCUMENT_TYPES = DOCUMENT_TYPES; exports.ENDPOINTS = ENDPOINTS; exports.HttpTransport = HttpTransport; exports.INGEST_MODES = INGEST_MODES; exports.ITEM_COLLECTIONS = ITEM_COLLECTIONS; exports.InsufficientCreditsError = _chunkHR5Y3KXScjs.InsufficientCreditsError; exports.InvalidConversationIdError = _chunkHR5Y3KXScjs.InvalidConversationIdError; exports.InvalidInputError = _chunkHR5Y3KXScjs.InvalidInputError; exports.InvalidInstanceIdError = _chunkHR5Y3KXScjs.InvalidInstanceIdError; exports.ListeningAlreadyActiveError = _chunkHR5Y3KXScjs.ListeningAlreadyActiveError; exports.ListeningNotActiveError = _chunkHR5Y3KXScjs.ListeningNotActiveError; exports.NetworkTimeoutError = _chunkHR5Y3KXScjs.NetworkTimeoutError; exports.PermanentError = _chunkHR5Y3KXScjs.PermanentError; exports.RateLimitError = _chunkHR5Y3KXScjs.RateLimitError; exports.SDKError = _chunkHR5Y3KXScjs.SDKError; exports.SDK_VERSION = SDK_VERSION; exports.ServiceUnavailableError = _chunkHR5Y3KXScjs.ServiceUnavailableError; exports.SessionExpiredError = _chunkHR5Y3KXScjs.SessionExpiredError; exports.SynapClient = SynapClient; exports.SynapError = _chunkHR5Y3KXScjs.SynapError; exports.SynapPermanentError = _chunkHR5Y3KXScjs.SynapPermanentError; exports.SynapTransientError = _chunkHR5Y3KXScjs.SynapTransientError; exports.THRESHOLDS = _chunkRB57I2IQcjs.THRESHOLDS; exports.TranscriptConflictError = _chunkHR5Y3KXScjs.TranscriptConflictError; exports.TransientError = _chunkHR5Y3KXScjs.TransientError; exports.flattenContextItems = flattenContextItems; exports.formatForPrompt = formatForPrompt; exports.isOutcomeUnknown = isOutcomeUnknown; exports.isRecallQuery = _chunkRB57I2IQcjs.isRecallQuery; exports.isSynapError = _chunkHR5Y3KXScjs.isSynapError; exports.mergeScopeResults = mergeScopeResults; exports.resolvePath = resolvePath; exports.shouldRetry = shouldRetry; exports.stem = _chunkRB57I2IQcjs.stem; exports.tokenize = _chunkRB57I2IQcjs.tokenize;
 //# sourceMappingURL=index.cjs.map