@maximem/synap-js-sdk 0.5.8 → 0.5.9

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;
 
 
 
@@ -8,7 +8,9 @@
 
 
 
-var _chunkT6U5PVADcjs = require('./chunk-T6U5PVAD.cjs');
+
+
+var _chunkICUFS3B5cjs = require('./chunk-ICUFS3B5.cjs');
 
 
 var _chunkZKOJDUN4cjs = require('./chunk-ZKOJDUN4.cjs');
@@ -55,6 +57,7 @@ var ENDPOINTS = {
   context_fetch_client: { method: "POST", path: "/v1/context/client/fetch", idempotent: true },
   context_fetch_conversation: { method: "POST", path: "/v1/context/conversation/fetch", idempotent: true },
   context_for_prompt: { method: "GET", path: "/v1/conversations/{conversation_id}/context-for-prompt", idempotent: true },
+  conversation_turns: { method: "GET", path: "/v1/conversations/{conversation_id}/messages", idempotent: true },
   conversations_ingest: { method: "POST", path: "/v1/conversations/ingest", idempotent: false },
   conversations_messages: { method: "POST", path: "/v1/conversations/messages", idempotent: false },
   conversations_messages_batch: { method: "POST", path: "/v1/conversations/messages/batch", idempotent: false },
@@ -132,7 +135,7 @@ var HEARTBEAT_INTERVAL_MS = 24e4;
 var MAX_CONNECTIONS = 20;
 var cached;
 function supportsDispatcher() {
-  return typeof process !== "undefined" && _optionalChain([process, 'access', _ => _.versions, 'optionalAccess', _2 => _2.node]) !== void 0 && // Edge builds of Next expose a partial `process` shim, but no real Node.
+  return typeof process !== "undefined" && _optionalChain([process, 'access', _2 => _2.versions, 'optionalAccess', _3 => _3.node]) !== void 0 && // Edge builds of Next expose a partial `process` shim, but no real Node.
   typeof globalThis.EdgeRuntime === "undefined";
 }
 async function getKeepAliveDispatcher(options = {}) {
@@ -173,7 +176,7 @@ var Heartbeat = (_class = class {
       void Promise.resolve(this.ping()).catch(() => {
       });
     }, this.intervalMs);
-    _optionalChain([this, 'access', _3 => _3.timer, 'access', _4 => _4.unref, 'optionalCall', _5 => _5()]);
+    _optionalChain([this, 'access', _4 => _4.timer, 'access', _5 => _5.unref, 'optionalCall', _6 => _6()]);
   }
   stop() {
     if (this.timer !== null) {
@@ -226,7 +229,7 @@ var HttpTransport = (_class2 = class {
     this.keepAliveOptions = _nullishCoalesce(options.keepAlive, () => ( {}));
     this.heartbeat = new Heartbeat(
       () => this.pingHealth(),
-      _nullishCoalesce(_optionalChain([options, 'access', _6 => _6.keepAlive, 'optionalAccess', _7 => _7.heartbeatIntervalMs]), () => ( HEARTBEAT_INTERVAL_MS))
+      _nullishCoalesce(_optionalChain([options, 'access', _7 => _7.keepAlive, 'optionalAccess', _8 => _8.heartbeatIntervalMs]), () => ( HEARTBEAT_INTERVAL_MS))
     );
   }
   /** Start keeping the connection warm. Opt-in: it is pointless in serverless. */
@@ -315,7 +318,7 @@ var HttpTransport = (_class2 = class {
         await sleep(decision.delaySeconds * 1e3, options.signal);
       }
     }
-    throw _nullishCoalesce(_optionalChain([last, 'optionalAccess', _8 => _8.error]), () => ( new (0, _chunkT372OL3Qcjs.SynapError)("Request failed with no recorded error")));
+    throw _nullishCoalesce(_optionalChain([last, 'optionalAccess', _9 => _9.error]), () => ( new (0, _chunkT372OL3Qcjs.SynapError)("Request failed with no recorded error")));
   }
   async attempt(name, options, correlationId) {
     const spec = ENDPOINTS[name];
@@ -394,17 +397,17 @@ function isOutcomeUnknown(error) {
   return true;
 }
 function isConnectionRefusal(error) {
-  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _9 => _9.cause, 'optionalAccess', _10 => _10.code]), () => ( _optionalChain([error, 'optionalAccess', _11 => _11.code])));
+  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _10 => _10.cause, 'optionalAccess', _11 => _11.code]), () => ( _optionalChain([error, 'optionalAccess', _12 => _12.code])));
   return code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EAI_AGAIN" || code === "ECONNRESET" || code === "EHOSTUNREACH";
 }
 function toTransportError(error, correlationId) {
   if (error instanceof _chunkT372OL3Qcjs.SynapError) return error;
-  const name = _optionalChain([error, 'optionalAccess', _12 => _12.name]);
+  const name = _optionalChain([error, 'optionalAccess', _13 => _13.name]);
   if (name === "AbortError" || name === "TimeoutError") {
     return new (0, _chunkT372OL3Qcjs.NetworkTimeoutError)("Request timed out", { correlationId, cause: error });
   }
   return new (0, _chunkT372OL3Qcjs.ServiceUnavailableError)(
-    `Network request failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _13 => _13.message]), () => ( String(error)))}`,
+    `Network request failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _14 => _14.message]), () => ( String(error)))}`,
     { correlationId, cause: error }
   );
 }
@@ -485,11 +488,11 @@ function stringOrNull(v) {
 }
 function withTimeout(ms, external) {
   const controller = new AbortController();
-  const onExternalAbort = () => controller.abort(_optionalChain([external, 'optionalAccess', _14 => _14.reason]));
+  const onExternalAbort = () => controller.abort(_optionalChain([external, 'optionalAccess', _15 => _15.reason]));
   const timer = setTimeout(() => {
     controller.abort(new (0, _chunkT372OL3Qcjs.NetworkTimeoutError)(`Timed out after ${ms}ms`));
   }, ms);
-  _optionalChain([timer, 'access', _15 => _15.unref, 'optionalCall', _16 => _16()]);
+  _optionalChain([timer, 'access', _16 => _16.unref, 'optionalCall', _17 => _17()]);
   if (external) {
     if (external.aborted) onExternalAbort();
     else external.addEventListener("abort", onExternalAbort, { once: true });
@@ -498,7 +501,7 @@ function withTimeout(ms, external) {
     signal: controller.signal,
     dispose() {
       clearTimeout(timer);
-      _optionalChain([external, 'optionalAccess', _17 => _17.removeEventListener, 'call', _18 => _18("abort", onExternalAbort)]);
+      _optionalChain([external, 'optionalAccess', _18 => _18.removeEventListener, 'call', _19 => _19("abort", onExternalAbort)]);
     }
   };
 }
@@ -506,17 +509,97 @@ function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      _optionalChain([signal, 'optionalAccess', _19 => _19.removeEventListener, 'call', _20 => _20("abort", onAbort)]);
+      _optionalChain([signal, 'optionalAccess', _20 => _20.removeEventListener, 'call', _21 => _21("abort", onAbort)]);
       resolve();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
-      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _21 => _21.reason]), () => ( new Error("Aborted"))));
+      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _22 => _22.reason]), () => ( new Error("Aborted"))));
     }
-    _optionalChain([signal, 'optionalAccess', _22 => _22.addEventListener, 'call', _23 => _23("abort", onAbort, { once: true })]);
+    _optionalChain([signal, 'optionalAccess', _23 => _23.addEventListener, 'call', _24 => _24("abort", onAbort, { once: true })]);
   });
 }
 
+// src/context/ranked.ts
+var RESPONSE_SHAPES = ["by_type", "ranked"];
+var MEMORY_TYPES = [
+  "facts",
+  "preferences",
+  "episodes",
+  "emotions",
+  "temporal_events"
+];
+var EXCERPT_CATEGORY = "excerpts";
+function wireRankScore(item) {
+  const md = item.metadata;
+  let raw = md !== null && typeof md === "object" ? md["rank_score"] : void 0;
+  if (raw === void 0 || raw === null) raw = item["rank_score"];
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function wireCategory(item, fallback = "") {
+  if (item.source === "chunks") return EXCERPT_CATEGORY;
+  const category = item["category"];
+  if (typeof category === "string" && category !== "") return category;
+  const contextType = item["context_type"];
+  if (typeof contextType === "string" && contextType !== "") return contextType;
+  return fallback;
+}
+function byRankScore(a, b) {
+  const sa = wireRankScore(a);
+  const sb = wireRankScore(b);
+  if (sa === null && sb === null) return 0;
+  if (sa === null) return 1;
+  if (sb === null) return -1;
+  return sb - sa;
+}
+function rankItems(byType) {
+  const flat = [];
+  for (const type of MEMORY_TYPES) {
+    const list = byType[type];
+    if (!Array.isArray(list)) continue;
+    for (const it of list) {
+      if (it === null || typeof it !== "object") continue;
+      flat.push({
+        ...it,
+        category: wireCategory(it, type),
+        id: it.id || it.item_id || ""
+      });
+    }
+  }
+  flat.sort(byRankScore);
+  return flat.map((it, n2) => ({ ...it, rank: n2 + 1 }));
+}
+function applyResponseShape(raw, shape = "by_type") {
+  const wire = raw["items"];
+  if (shape !== "ranked" && !Array.isArray(wire)) return raw;
+  const source = Array.isArray(wire) ? wire : rankItems(raw);
+  const items = source.map((it) => ({
+    ...it,
+    id: it.id || it.item_id || "",
+    category: wireCategory(it)
+  }));
+  const out = { ...raw, items };
+  for (const type of MEMORY_TYPES) {
+    out[type] = items.filter((it) => it["category"] === type);
+  }
+  out["excerpts"] = items.filter((it) => it["category"] === EXCERPT_CATEGORY);
+  return out;
+}
+var RANKED_LABELS = {
+  facts: "fact",
+  preferences: "preference",
+  episodes: "episode",
+  emotions: "emotion",
+  temporal_events: "temporal event",
+  [EXCERPT_CATEGORY]: "excerpt"
+};
+function rankedLabel(category) {
+  return _nullishCoalesce(RANKED_LABELS[category], () => ( (category !== "" ? category : "item")));
+}
+function sortByRankScore(items) {
+  return [...items].sort(byRankScore);
+}
+
 // src/context/fetch.ts
 var ENDPOINT_BY_SCOPE = {
   user: "context_fetch_user",
@@ -539,6 +622,7 @@ function buildFetchRequest(scope, options) {
   const precisionLevel = _nullishCoalesce(opt(options, "precision_level", "precisionLevel"), () => ( "high"));
   const queryDate = opt(options, "query_date", "queryDate");
   const perQuery = opt(options, "max_results_per_query", "maxResultsPerQuery");
+  const responseShape = responseShapeOf(options);
   const mode = _nullishCoalesce(options.mode, () => ( "fast"));
   if (searchQuery !== void 0 && !Array.isArray(searchQuery)) {
     throw new (0, _chunkT372OL3Qcjs.InvalidInputError)("search_query must be an array when provided");
@@ -556,6 +640,7 @@ function buildFetchRequest(scope, options) {
   if (precisionLevel !== "high") body["precision_level"] = precisionLevel;
   if (queryDate) body["query_date"] = queryDate;
   if (perQuery) body["max_results_per_query"] = perQuery;
+  if (responseShape !== "by_type") body["response_shape"] = responseShape;
   if (options.include_conversation_context === false) {
     body["include_conversation_context"] = false;
   }
@@ -603,22 +688,49 @@ function buildFetchRequest(scope, options) {
   return { endpoint: ENDPOINT_BY_SCOPE[scope], body };
 }
 var VALID_CONTEXT_MODES = ["in-conversation", "conversation-summary"];
+function responseShapeOf(options) {
+  const shape = _nullishCoalesce(opt(options, "response_shape", "responseShape"), () => ( "by_type"));
+  if (!RESPONSE_SHAPES.includes(shape)) {
+    throw new (0, _chunkT372OL3Qcjs.InvalidInputError)(
+      `Invalid response_shape '${shape}'. Must be one of: ${RESPONSE_SHAPES.join(", ")}`
+    );
+  }
+  return shape;
+}
 async function fetchContext(transport, scope, options = {}, hooks = {}) {
   const startedAt = Date.now();
   transport.checkCustomerId(
     opt(options, "customer_id", "customerId"),
     `${scope}.context.fetch`
   );
-  const anticipated = _nullishCoalesce(_optionalChain([hooks, 'access', _24 => _24.beforeFetch, 'optionalCall', _25 => _25(scope, options)]), () => ( null));
+  const responseShape = responseShapeOf(options);
+  const network = async () => {
+    const { endpoint, body } = buildFetchRequest(scope, options);
+    const result = await transport.request(endpoint, { body });
+    return applyResponseShape(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _25 => _25["context"]]), () => ( {})), responseShape);
+  };
+  const anticipated = await _asyncNullishCoalesce(await _optionalChain([hooks, 'access', _26 => _26.beforeFetch, 'optionalCall', _27 => _27(scope, options)]), async () => ( null));
+  if (anticipated !== null && anticipated.borderline) {
+    const pending = network();
+    pending.catch(() => void 0);
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), _nullishCoalesce(anticipated.raceDeadlineMs, () => ( 250)));
+    });
+    const won = await Promise.race([pending.then((r) => r, () => null), late]);
+    if (timer !== void 0) clearTimeout(timer);
+    if (won !== null) {
+      _optionalChain([hooks, 'access', _28 => _28.onAssembled, 'optionalCall', _29 => _29(scope, options, won, startedAt)]);
+      return won;
+    }
+  }
   if (anticipated !== null) {
-    _optionalChain([hooks, 'access', _26 => _26.onServedFromCache, 'optionalCall', _27 => _27(scope, options, anticipated)]);
-    _optionalChain([hooks, 'access', _28 => _28.onAssembled, 'optionalCall', _29 => _29(scope, options, anticipated.response, startedAt)]);
-    return anticipated.response;
-  }
-  const { endpoint, body } = buildFetchRequest(scope, options);
-  const result = await transport.request(endpoint, { body });
-  const response = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _30 => _30["context"]]), () => ( {}));
-  _optionalChain([hooks, 'access', _31 => _31.onAssembled, 'optionalCall', _32 => _32(scope, options, response, startedAt)]);
+    _optionalChain([hooks, 'access', _30 => _30.onServedFromCache, 'optionalCall', _31 => _31(scope, options, anticipated)]);
+    _optionalChain([hooks, 'access', _32 => _32.onAssembled, 'optionalCall', _33 => _33(scope, options, anticipated.response, startedAt)]);
+    return applyResponseShape(anticipated.response, responseShape);
+  }
+  const response = await network();
+  _optionalChain([hooks, 'access', _34 => _34.onAssembled, 'optionalCall', _35 => _35(scope, options, response, startedAt)]);
   return response;
 }
 
@@ -738,6 +850,17 @@ function normalizeConversationContext(value) {
     conversationId: pick(value["conversationId"], value.conversation_id, null)
   };
 }
+function normalizeRetrievalHealth(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const warnings = r["warnings"];
+  return {
+    degraded: r["degraded"] === void 0 ? true : Boolean(r["degraded"]),
+    level: _nullishCoalesce(r["level"], () => ( null)),
+    code: _nullishCoalesce(r["code"], () => ( null)),
+    warnings: Array.isArray(warnings) ? warnings.map((w) => String(w)) : []
+  };
+}
 function normalizeContextResponse(result = {}) {
   const context = _nullishCoalesce(result["context"], () => ( result));
   return {
@@ -754,7 +877,15 @@ function normalizeContextResponse(result = {}) {
       )
     ),
     metadata: normalizeContextMetadata(obj(context.metadata)),
-    rawResponse: pick(context["rawResponse"], context["raw_response"], {})
+    // `retrieval` is a SIBLING of `context` in the body, so it is read off the
+    // envelope first and only then off a bare context. Reading it from
+    // `context` alone is how the Python SDK dropped it.
+    retrieval: normalizeRetrievalHealth(
+      pick(result["retrieval"], context["retrieval"], null)
+    ),
+    rawResponse: pick(context["rawResponse"], context["raw_response"], {}),
+    // Only for a ranked fetch, so a by-type result has exactly the keys it had.
+    ...Array.isArray(context.items) ? { items: context.items, excerpts: Array.isArray(context.excerpts) ? context.excerpts : [] } : {}
   };
 }
 
@@ -1002,7 +1133,7 @@ function createMemoriesInterface(transport, onForgotten) {
       transport.checkCustomerId(_nullishCoalesce(o2["customer_id"], () => ( o2["customerId"])), "memories.forget");
       const body = buildForgetBody(options);
       const result = await transport.request("memories_forget", { body });
-      const removed = !!_optionalChain([result, 'optionalAccess', _33 => _33.deleted_ids, 'optionalAccess', _34 => _34.length]) || _optionalChain([result, 'optionalAccess', _35 => _35.status]) === "deleted" || _optionalChain([result, 'optionalAccess', _36 => _36.status]) === "partial";
+      const removed = !!_optionalChain([result, 'optionalAccess', _36 => _36.deleted_ids, 'optionalAccess', _37 => _37.length]) || _optionalChain([result, 'optionalAccess', _38 => _38.status]) === "deleted" || _optionalChain([result, 'optionalAccess', _39 => _39.status]) === "partial";
       if (removed && onForgotten) {
         try {
           onForgotten({
@@ -1042,14 +1173,14 @@ function sleep2(ms, signal) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      _optionalChain([signal, 'optionalAccess', _37 => _37.removeEventListener, 'call', _38 => _38("abort", onAbort)]);
+      _optionalChain([signal, 'optionalAccess', _40 => _40.removeEventListener, 'call', _41 => _41("abort", onAbort)]);
       resolve();
     }, ms);
     function onAbort() {
       clearTimeout(timer);
-      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _39 => _39.reason]), () => ( new Error("Aborted"))));
+      reject(_nullishCoalesce(_optionalChain([signal, 'optionalAccess', _42 => _42.reason]), () => ( new Error("Aborted"))));
     }
-    _optionalChain([signal, 'optionalAccess', _40 => _40.addEventListener, 'call', _41 => _41("abort", onAbort, { once: true })]);
+    _optionalChain([signal, 'optionalAccess', _43 => _43.addEventListener, 'call', _44 => _44("abort", onAbort, { once: true })]);
   });
 }
 
@@ -1069,6 +1200,27 @@ function validateInstanceId(instanceId) {
   }
 }
 
+// src/agent-model.ts
+var AGENT_MODEL_KEY = "agent_model";
+var AGENT_CONTEXT_WINDOW_KEY = "agent_context_window";
+function agentModelOf(options) {
+  const o2 = _nullishCoalesce(options, () => ( {}));
+  const window = _nullishCoalesce(o2["context_window"], () => ( o2["contextWindow"]));
+  return {
+    model: typeof o2["model"] === "string" ? o2["model"] : void 0,
+    contextWindow: typeof window === "number" ? window : void 0
+  };
+}
+function withAgentModel(metadata, perCall, defaults, asStrings = false) {
+  const model = perCall.model || defaults.model;
+  const window = perCall.contextWindow || defaults.contextWindow;
+  if (!model && !window) return metadata;
+  const out = { ..._nullishCoalesce(metadata, () => ( {})) };
+  if (model) out[AGENT_MODEL_KEY] = String(model);
+  if (window) out[AGENT_CONTEXT_WINDOW_KEY] = asStrings ? String(Math.trunc(window)) : Math.trunc(window);
+  return out;
+}
+
 // src/conversation/interface.ts
 var COMPACTION_LEVELS = [
   "low",
@@ -1197,10 +1349,50 @@ var CompactionSubscribers = class {
     }
   }
 };
+function storedBatchRows(bodies, result) {
+  const r = _nullishCoalesce(result, () => ( {}));
+  const results = Array.isArray(r["results"]) ? r["results"] : [];
+  const errors = Array.isArray(r["errors"]) ? r["errors"] : [];
+  const failed = new Set(errors.map((e) => _optionalChain([e, 'optionalAccess', _45 => _45["index"]])));
+  const stored = bodies.filter((_, index) => !failed.has(index));
+  if (stored.length !== results.length) return [];
+  const pairs = [];
+  stored.forEach((body, i) => {
+    const row = results[i];
+    if (row && typeof row === "object" && row["message_id"]) pairs.push([body, row]);
+  });
+  return pairs;
+}
 function createConversationNamespace(transport, subscribers = new CompactionSubscribers(), onWrite = () => {
 }, onTurn = () => {
 }, onFetched = () => {
-}, localShortTerm = { prompt: () => null, compacted: () => null }) {
+}, localShortTerm = { prompt: () => null, compacted: () => null }, agentModel = () => ({})) {
+  const writesInFlight = /* @__PURE__ */ new Map();
+  const withTurnModel = (body, options) => {
+    const metadata = withAgentModel(
+      body["metadata"],
+      agentModelOf(options),
+      agentModel()
+    );
+    return metadata === void 0 ? body : { ...body, metadata };
+  };
+  const writeStarted = (conversationId) => {
+    writesInFlight.set(conversationId, (_nullishCoalesce(writesInFlight.get(conversationId), () => ( 0))) + 1);
+  };
+  const writeLanded = (conversationId) => {
+    const remaining = (_nullishCoalesce(writesInFlight.get(conversationId), () => ( 0))) - 1;
+    if (remaining > 0) writesInFlight.set(conversationId, remaining);
+    else writesInFlight.delete(conversationId);
+  };
+  const confirmation = (result, conversationId) => {
+    const r = _nullishCoalesce(result, () => ( {}));
+    const count = r["conversation_message_count"];
+    return {
+      ...typeof r["message_id"] === "string" ? { messageId: r["message_id"] } : {},
+      serverMessageCount: typeof count === "number" ? count : null,
+      inFlight: _nullishCoalesce(writesInFlight.get(conversationId), () => ( 0))
+    };
+  };
   const convId = (v) => {
     const id = typeof v === "string" ? v : _nullishCoalesce(v.conversation_id, () => ( v.conversationId));
     if (!id) throw new (0, _chunkT372OL3Qcjs.InvalidInputError)("conversation_id is required");
@@ -1213,13 +1405,21 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
         _nullishCoalesce(options["customer_id"], () => ( options["customerId"])),
         "conversation.record_message"
       );
-      const body = buildRecordMessageBody(options);
-      const result = await transport.request("conversations_messages", { body });
+      const body = withTurnModel(buildRecordMessageBody(options), options);
+      const conversationId = String(_nullishCoalesce(body["conversation_id"], () => ( "")));
+      writeStarted(conversationId);
+      let result;
+      try {
+        result = await transport.request("conversations_messages", { body });
+      } finally {
+        writeLanded(conversationId);
+      }
       onTurn({
-        conversationId: String(_nullishCoalesce(body["conversation_id"], () => ( ""))),
+        conversationId,
         role: String(_nullishCoalesce(body["role"], () => ( "user"))),
         content: String(_nullishCoalesce(body["content"], () => ( ""))),
-        timestamp: body["timestamp"]
+        timestamp: body["timestamp"],
+        ...confirmation(result, conversationId)
       });
       onWrite({
         userId: body["user_id"],
@@ -1238,16 +1438,18 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
           "conversation.record_messages_batch"
         );
       }
-      const bodies = messages.map(buildRecordMessageBody);
+      const bodies = messages.map((m) => withTurnModel(buildRecordMessageBody(m), m));
       const result = await transport.request("conversations_messages_batch", {
         body: { messages: bodies }
       });
-      for (const body of bodies) {
+      for (const [body, row] of storedBatchRows(bodies, result)) {
+        const conversationId = String(_nullishCoalesce(body["conversation_id"], () => ( "")));
         onTurn({
-          conversationId: String(_nullishCoalesce(body["conversation_id"], () => ( ""))),
+          conversationId,
           role: String(_nullishCoalesce(body["role"], () => ( "user"))),
           content: String(_nullishCoalesce(body["content"], () => ( ""))),
-          timestamp: body["timestamp"]
+          timestamp: body["timestamp"],
+          ...confirmation(row, conversationId)
         });
       }
       for (const body of bodies) {
@@ -1282,13 +1484,24 @@ function createConversationNamespace(transport, subscribers = new CompactionSubs
       },
       get_context_for_prompt: async (options = {}) => {
         const id = convId(options);
+        const search = (_nullishCoalesce(_nullishCoalesce(options.search_history, () => ( options.searchHistory)), () => ( true))) && localShortTerm.historyExcerpts;
+        const withHistory = async (response2) => {
+          if (!search) return response2;
+          try {
+            return await localShortTerm.historyExcerpts(id, response2, options.query);
+          } catch (e6) {
+            return response2;
+          }
+        };
         const local = localShortTerm.prompt(id, _nullishCoalesce(options.style, () => ( "structured")));
-        if (local !== null) return local;
+        if (local !== null) return withHistory(local);
         const result = await transport.request("context_for_prompt", {
           pathParams: { conversation_id: id },
           query: { style: _nullishCoalesce(options.style, () => ( "structured")) }
         });
-        return _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _42 => _42["context_for_prompt"]]), () => ( result)), () => ( {}));
+        const response = _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _46 => _46["context_for_prompt"]]), () => ( result)), () => ( {}));
+        _optionalChain([localShortTerm, 'access', _47 => _47.reseed, 'optionalCall', _48 => _48(id, response)]);
+        return withHistory(response);
       },
       async compact(options) {
         return transport.request("conversations_compact", { body: buildCompactBody(options) });
@@ -1463,32 +1676,40 @@ function jsonOrText(value) {
       (_k, v) => typeof v === "bigint" ? String(v) : v
     );
     return out === void 0 ? String(value) : out;
-  } catch (e6) {
+  } catch (e7) {
     try {
       return String(value);
-    } catch (e7) {
+    } catch (e8) {
       return "";
     }
   }
 }
-function createInstanceNamespace(credentials, cache, onTurn) {
+function createInstanceNamespace(credentials, cache, onTurn, agentModel = () => ({}), onToolResult) {
   let client = null;
   const openSessions = /* @__PURE__ */ new Map();
   let dispatchCompaction = null;
   let applyCompaction = null;
+  let onListen = null;
+  let onConversationState = null;
   const internals = {
     onCompactionUpdate(conversationId, bundle) {
-      _optionalChain([applyCompaction, 'optionalCall', _43 => _43(bundle)]);
-      _optionalChain([dispatchCompaction, 'optionalCall', _44 => _44(conversationId, bundle)]);
+      _optionalChain([applyCompaction, 'optionalCall', _49 => _49(bundle)]);
+      _optionalChain([dispatchCompaction, 'optionalCall', _50 => _50(conversationId, bundle)]);
     },
     setCompactionApplier(apply) {
       applyCompaction = apply;
     },
+    setOnListen(handle) {
+      onListen = handle;
+    },
+    setConversationStateHandler(handle) {
+      onConversationState = handle;
+    },
     sendContextUsed(event) {
-      _optionalChain([client, 'optionalAccess', _45 => _45.sendContextUsed, 'call', _46 => _46(event)]);
+      _optionalChain([client, 'optionalAccess', _51 => _51.sendContextUsed, 'call', _52 => _52(event)]);
     },
     sendContextAssembled(event) {
-      _optionalChain([client, 'optionalAccess', _47 => _47.sendContextAssembled, 'call', _48 => _48(event)]);
+      _optionalChain([client, 'optionalAccess', _53 => _53.sendContextAssembled, 'call', _54 => _54(event)]);
     },
     setCompactionDispatcher(dispatch) {
       dispatchCompaction = dispatch;
@@ -1510,7 +1731,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
         ...customerId ? { customer_id: customerId } : {}
       });
       openSessions.set(conversationId, sessionId);
-    } catch (e8) {
+    } catch (e9) {
     }
   }
   const namespace = {
@@ -1518,7 +1739,11 @@ function createInstanceNamespace(credentials, cache, onTurn) {
       if (client !== null) {
         throw new (0, _chunkT372OL3Qcjs.ListeningAlreadyActiveError)("Listening is already active on this instance");
       }
-      const { GrpcStreamClient } = await Promise.resolve().then(() => _interopRequireWildcard(require("./stream-client-N46JBT5A.cjs")));
+      try {
+        _optionalChain([onListen, 'optionalCall', _55 => _55()]);
+      } catch (e10) {
+      }
+      const { GrpcStreamClient } = await Promise.resolve().then(() => _interopRequireWildcard(require("./stream-client-L6OQPZN7.cjs")));
       const onContext = _nullishCoalesce(options.on_context, () => ( options.onContext));
       const onDisconnect = _nullishCoalesce(options.on_disconnect, () => ( options.onDisconnect));
       const onReconnect = _nullishCoalesce(options.on_reconnect, () => ( options.onReconnect));
@@ -1532,15 +1757,18 @@ function createInstanceNamespace(credentials, cache, onTurn) {
         onCompactionUpdate: (conversationId, bundle) => {
           internals.onCompactionUpdate(conversationId, bundle);
         },
+        onConversationState: (conversationId, messageCount) => {
+          _optionalChain([onConversationState, 'optionalCall', _56 => _56(conversationId, messageCount)]);
+        },
         onStateChange: (state) => {
           if (state !== "connected") openSessions.clear();
           if (state === "reconnecting") {
             reconnectAttempts += 1;
-            _optionalChain([onReconnect, 'optionalCall', _49 => _49(reconnectAttempts)]);
+            _optionalChain([onReconnect, 'optionalCall', _57 => _57(reconnectAttempts)]);
           } else if (state === "disconnected") {
-            const stopped = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _50 => _50.lastError]), () => ( null));
+            const stopped = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _58 => _58.lastError]), () => ( null));
             const reason = stopped === null ? "stream disconnected" : `credit_stop:${_nullishCoalesce(stopped.reason, () => ( "unknown"))}`;
-            _optionalChain([onDisconnect, 'optionalCall', _51 => _51(reason)]);
+            _optionalChain([onDisconnect, 'optionalCall', _59 => _59(reason)]);
           }
         }
       });
@@ -1550,7 +1778,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
       } catch (error) {
         if (error instanceof _chunkT372OL3Qcjs.SynapError) throw error;
         throw new (0, _chunkT372OL3Qcjs.SynapError)(
-          `Could not open the Synap anticipation stream: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _52 => _52.message]), () => ( String(error)))}`,
+          `Could not open the Synap anticipation stream: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _60 => _60.message]), () => ( String(error)))}`,
           { cause: error }
         );
       }
@@ -1575,7 +1803,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
           session_id: sessionId,
           conversation_id: conversationId
         });
-      } catch (e9) {
+      } catch (e11) {
       }
     },
     async send_message(options) {
@@ -1596,7 +1824,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
         _nullishCoalesce(_nullishCoalesce(options.customer_id, () => ( options.customerId)), () => ( ""))
       );
       if (eventType === "user_message" || eventType === "assistant_message") {
-        _optionalChain([onTurn, 'optionalCall', _53 => _53({
+        _optionalChain([onTurn, 'optionalCall', _61 => _61({
           conversationId,
           role: _nullishCoalesce(options.role, () => ( "user")),
           content: options.content
@@ -1610,7 +1838,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
         user_id: _nullishCoalesce(_nullishCoalesce(options.user_id, () => ( options.userId)), () => ( "")),
         customer_id: _nullishCoalesce(_nullishCoalesce(options.customer_id, () => ( options.customerId)), () => ( "")),
         session_id: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(options.session_id, () => ( options.sessionId)), () => ( openSessions.get(conversationId))), () => ( "")),
-        metadata: _nullishCoalesce(options.metadata, () => ( {})),
+        metadata: _nullishCoalesce(withAgentModel(options.metadata, agentModelOf(options), agentModel(), true), () => ( {})),
         timestamp_ms: Date.now(),
         tool_name: _nullishCoalesce(_nullishCoalesce(options.tool_name, () => ( options.toolName)), () => ( "")),
         // Python serialises tool_args with json.dumps into tool_args_json.
@@ -1640,6 +1868,10 @@ function createInstanceNamespace(credentials, cache, onTurn) {
       });
     },
     async record_tool_result(options) {
+      const conversationId = _nullishCoalesce(_nullishCoalesce(options.conversation_id, () => ( options.conversationId)), () => ( ""));
+      if (conversationId) {
+        _optionalChain([onToolResult, 'optionalCall', _62 => _62({ conversationId, result: options.result, toolName: _nullishCoalesce(_nullishCoalesce(options.tool_name, () => ( options.toolName)), () => ( "")) })]);
+      }
       await namespace.send_message({
         content: "",
         role: "tool",
@@ -1690,7 +1922,7 @@ function createInstanceNamespace(credentials, cache, onTurn) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.5.8";
+var SDK_VERSION = "0.5.9";
 
 // src/registry.ts
 var instances = /* @__PURE__ */ new Map();
@@ -1731,6 +1963,34 @@ function unregisterIfOwner(key, client) {
 // src/cache/short-term-store.ts
 var DEFAULT_MAX_CONVERSATIONS = 100;
 var DEFAULT_MAX_AGE_MS = 12 * 60 * 60 * 1e3;
+var CONTEXT_BLOCK_PREFIX = "## Conversation so far (compacted";
+function contextBlockOf(cc) {
+  const block = cc["context_block"];
+  if (typeof block === "string" && block) return block;
+  const summary = cc["summary"];
+  if (typeof summary === "string" && summary.startsWith(CONTEXT_BLOCK_PREFIX)) return summary;
+  return null;
+}
+function localMessageCount(entry) {
+  return entry.compactedMessageCount + entry.recentTurns.length;
+}
+function isComplete(entry) {
+  return entry.participant && entry.synced && !entry.shared && entry.serverMessageCount !== null && entry.serverMessageCount <= localMessageCount(entry);
+}
+function heldIn(turn, turns) {
+  return turns.some(
+    (held) => turn.message_id && held.message_id ? held.message_id === turn.message_id : held.role === turn.role && held.content === turn.content
+  );
+}
+function turnsAfter(localTurns, serverTurns) {
+  const newer = [];
+  for (let i = localTurns.length - 1; i >= 0; i -= 1) {
+    const turn = localTurns[i];
+    if (heldIn(turn, serverTurns)) break;
+    newer.unshift(turn);
+  }
+  return newer;
+}
 function parseIso(value) {
   if (value === null || value === void 0 || value === "") return null;
   if (value instanceof Date) return value.getTime();
@@ -1750,11 +2010,23 @@ var ShortTermStore = class {
   #maxConversations;
   #maxAgeMs;
   #now;
+  /**
+   * Every turn appended here is also kept in the archive (a TurnStore), which
+   * a compaction does not prune: the turns it covers stay searchable locally
+   * (history-search.ts). Python: `ShortTermContextStore.attach_archive`.
+   */
+  #archive = null;
   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())));
   }
+  attachArchive(archive) {
+    this.#archive = archive;
+  }
+  get archive() {
+    return this.#archive;
+  }
   /** The entry, or null. Age-evicts on read, as Python does. */
   get(conversationId) {
     if (!conversationId) return null;
@@ -1780,23 +2052,88 @@ var ShortTermStore = class {
    * 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.
+   *
+   * `confirmation` is what the write learned from the server. See
+   * `TurnConfirmation` and `noteServerCount`.
    */
-  appendTurn(conversationId, role, content, timestamp) {
+  appendTurn(conversationId, role, content, timestamp, confirmation = {}) {
     if (!conversationId) return;
     const stamp = _nullishCoalesce(timestamp, () => ( new Date(this.#now()).toISOString()));
+    if (this.#archive !== null) {
+      try {
+        this.#archive.add(conversationId, role, content, stamp, { messageId: _nullishCoalesce(confirmation.messageId, () => ( null)) });
+      } catch (e12) {
+      }
+    }
     const entry = _nullishCoalesce(this.#entries.get(conversationId), () => ( this.#blank(conversationId)));
-    entry.recentTurns.push({ role, content, timestamp: stamp });
+    const messageId = confirmation.messageId;
+    const alreadyHeld = Boolean(messageId) && entry.recentTurns.some((t) => t.message_id === messageId);
+    if (!alreadyHeld) {
+      const turn = { role, content, timestamp: stamp };
+      if (messageId) turn.message_id = messageId;
+      entry.recentTurns.push(turn);
+    }
+    const count = confirmation.serverMessageCount;
+    if (count !== null && count !== void 0) {
+      this.#noteCount(entry, Number(count), _nullishCoalesce(confirmation.inFlight, () => ( 0)));
+    }
     entry.lastActivityAt = _nullishCoalesce(parseIso(stamp), () => ( this.#now()));
     this.#touch(conversationId, entry);
     this.#evict();
   }
+  /**
+   * Record the server's message count for a conversation.
+   *
+   * The streamed write path's half of `appendTurn`'s confirmation: a streamed
+   * turn is appended when it is sent, and the count arrives later, once the
+   * server has written it. A count for a conversation this process holds
+   * nothing for is ignored.
+   */
+  noteServerCount(conversationId, count) {
+    if (!conversationId) return;
+    const entry = this.#entries.get(conversationId);
+    if (entry !== void 0) this.#noteCount(entry, Number(count), 0);
+  }
+  /**
+   * Compare the server's count with what the entry holds.
+   *
+   * The count is taken after one of this process's own writes, so it proves
+   * the process takes part in the conversation.
+   *
+   * Server ahead of an entry that was in sync: something else wrote, and the
+   * entry is marked shared for good. Server ahead of an entry that was never
+   * in sync: this process joined late (a restart, an eviction), and `reseed`
+   * will fix it. `inFlight` covers this process's own writes that the server
+   * has counted and the entry has not appended yet, so two concurrent writes
+   * do not look like a second writer.
+   */
+  #noteCount(entry, count, inFlight) {
+    entry.participant = true;
+    if (count > localMessageCount(entry) + inFlight) {
+      if (entry.synced) entry.shared = true;
+    } else if (entry.serverMessageCount === null) {
+      entry.synced = true;
+    }
+    entry.serverMessageCount = Math.max(_nullishCoalesce(entry.serverMessageCount, () => ( 0)), count);
+  }
   /**
    * 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.
+   * drops the buffered turns the new summary covers.
+   *
+   * Which turns those are is decided by count, not by clock. The bundle says
+   * how many messages the summary covers and how many the conversation held
+   * when the bundle was built, so the last `total - compacted` of its
+   * `recent_turns` are exactly the uncovered messages. Turns this process
+   * appended after the server took that count are kept behind them. Timestamps
+   * cannot do this job: the REST write returns the time of the response and
+   * not of the stored row, a caller may supply its own message time, and a
+   * streamed turn is stamped when a background write runs.
+   *
+   * A bundle from a server that sends no counts falls back to the older
+   * timestamp prune, and the entry is left out of sync so it is never used to
+   * answer on its own.
    */
   applyCompaction(bundle) {
     if (typeof bundle !== "object" || bundle === null) return;
@@ -1806,22 +2143,84 @@ var ShortTermStore = class {
     );
     if (!conversationId) return;
     const endTs = parseIso(_nullishCoalesce(cc["end_timestamp"], () => ( cc["compacted_at"])));
+    const compactedAt = parseIso(cc["compacted_at"]);
+    const compactedCount = Number(_nullishCoalesce(cc["compacted_message_count"], () => ( 0))) || 0;
+    const totalCount = Number(_nullishCoalesce(cc["total_message_count"], () => ( 0))) || 0;
     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;
+    const heldAt = parseIso(entry.compactedAt);
+    if (compactedAt !== null && heldAt !== null && compactedAt < heldAt) return;
+    const block = contextBlockOf(cc);
+    if (block) {
+      entry.contextBlock = block;
+      entry.summary = cc["summary"] || block;
+      entry.factualParagraph = null;
+      entry.conversationalParagraph = null;
+    } else {
+      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));
+    if (compactedCount > 0 && compactedCount <= totalCount) {
+      const uncovered = totalCount - compactedCount;
+      const serverTurns = Array.isArray(cc["recent_turns"]) ? cc["recent_turns"] : [];
+      const tail = uncovered > 0 ? serverTurns.slice(-uncovered).map((t) => ({ ...t })) : [];
+      const ahead = localMessageCount(entry) - totalCount;
+      const newer = entry.synced && ahead > 0 ? entry.recentTurns.slice(-ahead).filter((t) => !heldIn(t, tail)) : [];
+      entry.recentTurns = [...tail, ...newer];
+      entry.compactedMessageCount = compactedCount;
+      entry.serverMessageCount = Math.max(_nullishCoalesce(entry.serverMessageCount, () => ( 0)), totalCount);
+      entry.synced = tail.length === uncovered;
+    } else {
+      if (endTs !== null && entry.recentTurns.length > 0) {
+        entry.recentTurns = entry.recentTurns.filter((t) => isAfter(t.timestamp, endTs));
+      }
+      entry.synced = false;
     }
     entry.lastActivityAt = this.#now();
     this.#touch(conversationId, entry);
     this.#evict();
   }
+  /**
+   * Bring an entry back in step from a `/context-for-prompt` response.
+   *
+   * Called after the server was asked because the entry was not complete. The
+   * response lists every message the server's summary does not cover, which is
+   * what `recentTurns` is meant to hold.
+   *
+   * Only an entry that already exists is reseeded. Creating one here would let
+   * a process that never writes to the conversation answer from a snapshot it
+   * has no way to refresh.
+   *
+   * If the server's summary is not the one cached here, the entry cannot
+   * render it, so it stays out of sync until the next bundle brings the
+   * summary itself.
+   *
+   * Turns held locally and absent from the response are kept when they come
+   * after everything the response has: they were written or sent after the
+   * server read its messages.
+   */
+  reseed(conversationId, state) {
+    if (!conversationId) return;
+    const entry = this.#entries.get(conversationId);
+    if (entry === void 0 || entry.shared) return;
+    entry.serverMessageCount = Math.max(
+      _nullishCoalesce(entry.serverMessageCount, () => ( 0)),
+      Number(state.totalMessageCount) || 0
+    );
+    if ((state.compactionId || null) !== entry.compactionId) {
+      entry.synced = false;
+      return;
+    }
+    const serverTurns = state.recentMessages.map((m) => ({ ...m }));
+    entry.recentTurns = [...serverTurns, ...turnsAfter(entry.recentTurns, serverTurns)];
+    entry.compactedMessageCount = Number(state.compactedMessageCount) || 0;
+    entry.synced = true;
+  }
   invalidate(conversationId) {
     this.#entries.delete(conversationId);
   }
@@ -1832,6 +2231,7 @@ var ShortTermStore = class {
     return {
       conversationId,
       summary: null,
+      contextBlock: null,
       factualParagraph: null,
       conversationalParagraph: null,
       currentState: {},
@@ -1840,7 +2240,12 @@ var ShortTermStore = class {
       compactedAt: null,
       endTimestamp: null,
       recentTurns: [],
-      lastActivityAt: this.#now()
+      lastActivityAt: this.#now(),
+      compactedMessageCount: 0,
+      serverMessageCount: null,
+      participant: false,
+      synced: false,
+      shared: false
     };
   }
   /** Re-insert so this key becomes the most recently used. */
@@ -1857,6 +2262,520 @@ var ShortTermStore = class {
   }
 };
 
+// src/cache/turn-store.ts
+var SWEEP_EVERY_WRITES = 50;
+function bytesOf(text) {
+  return new TextEncoder().encode(text).length;
+}
+var TurnStore = (_class3 = class {
+  
+  __init4() {this.onDisk = false}
+  #now;
+  #seq = 0;
+  #writes = 0;
+  #conversations = /* @__PURE__ */ new Map();
+  #vectors = /* @__PURE__ */ new Map();
+  constructor(options = {}) {;_class3.prototype.__init4.call(this);
+    this.limits = _nullishCoalesce(options.limits, () => ( { ..._chunkICUFS3B5cjs.HISTORY_SEARCH.store_limits }));
+    this.#now = _nullishCoalesce(options.now, () => ( (() => Date.now() / 1e3)));
+  }
+  add(conversationId, role, content, timestamp, options = {}) {
+    this.addMany(conversationId, [
+      { role, content, timestamp: _nullishCoalesce(timestamp, () => ( "")), message_id: _nullishCoalesce(options.messageId, () => ( null)), position: _nullishCoalesce(options.position, () => ( null)) }
+    ]);
+  }
+  /**
+   * Insert turns not held yet; returns how many were new. A turn held without
+   * an id or position (a streamed write) gets them when the same role and
+   * text come back from the server.
+   */
+  addMany(conversationId, turns) {
+    if (!conversationId) return 0;
+    const conv = _nullishCoalesce(this.#conversations.get(conversationId), () => ( { lastActivity: 0, turns: [] }));
+    let added = 0;
+    for (const turn of turns) {
+      const role = String(turn.role || "user");
+      const content = String(_nullishCoalesce(turn.content, () => ( "")));
+      if (!content) continue;
+      const messageId = turn.message_id ? String(turn.message_id) : null;
+      const raw = turn.position;
+      const position = typeof raw === "number" && Number.isInteger(raw) ? raw : /^\d+$/.test(String(_nullishCoalesce(raw, () => ( "")))) ? Number(raw) : null;
+      const ts = turn.timestamp instanceof Date ? turn.timestamp.toISOString() : String(_nullishCoalesce(turn.timestamp, () => ( "")));
+      if (messageId !== null) {
+        const held = conv.turns.find((t) => t.message_id === messageId);
+        if (held !== void 0) {
+          if (position !== null) held.position = position;
+          continue;
+        }
+      }
+      const same = conv.turns.find(
+        (t) => t.role === role && t.content === content && (t.message_id === null || t.position === null)
+      );
+      if (same !== void 0) {
+        same.message_id = _nullishCoalesce(same.message_id, () => ( messageId));
+        same.position = _nullishCoalesce(position, () => ( same.position));
+        continue;
+      }
+      conv.turns.push({ seq: ++this.#seq, role, content, timestamp: ts, message_id: messageId, position });
+      added += 1;
+    }
+    conv.lastActivity = this.#now();
+    this.#conversations.set(conversationId, conv);
+    this.#trim(conv);
+    this.#writes += 1;
+    if (this.#writes % SWEEP_EVERY_WRITES === 0) this.sweep();
+    return added;
+  }
+  #trim(conv) {
+    const limits = this.limits;
+    let size = conv.turns.reduce((n2, t) => n2 + bytesOf(t.content), 0);
+    while (conv.turns.length > limits.max_turns_per_conversation || size > limits.max_bytes_per_conversation) {
+      const excess = Math.max(conv.turns.length - limits.max_turns_per_conversation, 1);
+      const order = [...conv.turns].sort(
+        (a, b) => (_nullishCoalesce(a.position, () => ( Number.MAX_SAFE_INTEGER))) - (_nullishCoalesce(b.position, () => ( Number.MAX_SAFE_INTEGER))) || a.seq - b.seq
+      );
+      const gone = new Set(order.slice(0, excess).map((t) => t.seq));
+      if (gone.size === 0) break;
+      for (const t of conv.turns) if (gone.has(t.seq)) size -= bytesOf(t.content);
+      conv.turns = conv.turns.filter((t) => !gone.has(t.seq));
+      for (const vectors of this.#vectors.values()) for (const seq of gone) vectors.delete(seq);
+    }
+  }
+  /** Idle conversations, then the least recently used beyond the count, then more until the bytes fit. */
+  sweep() {
+    const limits = this.limits;
+    const now = this.#now();
+    for (const [id, conv] of this.#conversations) {
+      if (conv.lastActivity < now - limits.idle_ttl_seconds) this.drop(id);
+    }
+    const byRecent = [...this.#conversations.entries()].sort((a, b) => b[1].lastActivity - a[1].lastActivity);
+    for (const [id] of byRecent.slice(limits.max_conversations)) this.drop(id);
+    while (this.sizeBytes() > limits.max_file_bytes) {
+      const oldest = this.conversations()[0];
+      if (oldest === void 0) break;
+      this.drop(oldest);
+    }
+  }
+  drop(conversationId) {
+    const conv = this.#conversations.get(conversationId);
+    if (conv === void 0) return;
+    for (const vectors of this.#vectors.values()) for (const t of conv.turns) vectors.delete(t.seq);
+    this.#conversations.delete(conversationId);
+  }
+  clear() {
+    this.#conversations.clear();
+    this.#vectors.clear();
+  }
+  close() {
+  }
+  /** In conversation order: by server position where known, else as written here. */
+  turns(conversationId) {
+    const conv = this.#conversations.get(conversationId);
+    if (conv === void 0) return [];
+    const bySeq = [...conv.turns].sort((a, b) => a.seq - b.seq);
+    const key = /* @__PURE__ */ new Map();
+    let top = 0;
+    let step = 0;
+    for (const t of bySeq) {
+      if (t.position !== null) {
+        key.set(t.seq, t.position);
+        top = Math.max(top, t.position);
+        step = 0;
+      } else {
+        step += 1;
+        key.set(t.seq, top + step * 1e-6);
+      }
+    }
+    return bySeq.sort((a, b) => (_nullishCoalesce(key.get(a.seq), () => ( 0))) - (_nullishCoalesce(key.get(b.seq), () => ( 0))) || a.seq - b.seq).map((t) => ({ ...t }));
+  }
+  /** Turns the server also holds: archived tool results are local only. Python: `count`. */
+  count(conversationId) {
+    return (_nullishCoalesce(_optionalChain([this, 'access', _63 => _63.#conversations, 'access', _64 => _64.get, 'call', _65 => _65(conversationId), 'optionalAccess', _66 => _66.turns]), () => ( []))).filter((t) => t.role !== "tool").length;
+  }
+  sizeBytes() {
+    let n2 = 0;
+    for (const conv of this.#conversations.values()) for (const t of conv.turns) n2 += bytesOf(t.content);
+    return n2;
+  }
+  /** Conversation ids, least recently active first. */
+  conversations() {
+    return [...this.#conversations.entries()].sort((a, b) => a[1].lastActivity - b[1].lastActivity).map(([id]) => id);
+  }
+  vectors(seqs, model) {
+    const held = this.#vectors.get(model);
+    const out = /* @__PURE__ */ new Map();
+    if (held === void 0) return out;
+    for (const seq of seqs) {
+      const v = held.get(seq);
+      if (v !== void 0) out.set(seq, v);
+    }
+    return out;
+  }
+  putVectors(model, items) {
+    const held = _nullishCoalesce(this.#vectors.get(model), () => ( /* @__PURE__ */ new Map()));
+    for (const [seq, vec] of items) held.set(seq, vec);
+    this.#vectors.set(model, held);
+  }
+}, _class3);
+
+// src/cache/history-search.ts
+var WORD_RE = /[\p{L}\p{N}\p{M}]+/gu;
+var FORMS = _nullishCoalesce(_chunkICUFS3B5cjs.HISTORY_SEARCH.irregular_forms, () => ( {}));
+function tokenize2(text) {
+  const out = [];
+  for (const word of _nullishCoalesce((text || "").toLowerCase().match(WORD_RE), () => ( []))) {
+    if (/^[\x00-\x7f]+$/.test(word)) out.push(..._chunkICUFS3B5cjs.tokenize.call(void 0, _nullishCoalesce(FORMS[word], () => ( word))));
+    else out.push(word);
+  }
+  return out;
+}
+var LITERAL_SOURCE = String.raw`"([^"]{3,})"|\b([A-Z0-9][A-Z0-9-]{3,})\b|(\d[\d,.:/-]*\d|\d)`;
+var SENTENCE_RE = /(?<=[.!?])\s+/;
+function literalsOf(query) {
+  const out = [];
+  for (const m of (query || "").matchAll(new RegExp(LITERAL_SOURCE, "g"))) {
+    const quoted = m[1];
+    const value = quoted || m[2] || m[3];
+    if (value && (quoted || /\d/.test(value))) out.push(value.toLowerCase());
+  }
+  return out;
+}
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n2 = Math.min(a.length, b.length);
+  for (let i = 0; i < n2; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+}
+function words(text) {
+  return text.split(/\s+/).filter(Boolean);
+}
+function excerptOf(content, terms, literals, maxWords) {
+  let sentences = content.trim().split(SENTENCE_RE).filter((s2) => s2.trim());
+  if (sentences.length === 0) sentences = [content.trim()];
+  const score = (sentence) => {
+    const low = sentence.toLowerCase();
+    const held = new Set(tokenize2(sentence));
+    let n2 = 0;
+    for (const t of terms) if (held.has(t)) n2 += 1;
+    for (const lit of literals) if (low.includes(lit)) n2 += 2;
+    return n2;
+  };
+  let best = 0;
+  for (let i = 1; i < sentences.length; i++) if (score(sentences[i]) > score(sentences[best])) best = i;
+  let lo = best;
+  let hi = best;
+  let count = words(sentences[best]).length;
+  for (; ; ) {
+    let grew = false;
+    for (const j of [hi + 1, lo - 1]) {
+      if (j >= 0 && j < sentences.length && count + words(sentences[j]).length <= maxWords) {
+        count += words(sentences[j]).length;
+        lo = Math.min(lo, j);
+        hi = Math.max(hi, j);
+        grew = true;
+      }
+    }
+    if (!grew) break;
+  }
+  let text = sentences.slice(lo, hi + 1).join(" ");
+  if (words(text).length > maxWords) text = words(text).slice(0, maxWords).join(" ") + " ...";
+  return (lo > 0 ? "... " : "") + text + (hi < sentences.length - 1 && !text.endsWith("...") ? " ..." : "");
+}
+var FENCE = /^\s*(?:```|~~~)/;
+var TABLE_RULE = /^\s*\|?\s*:?-{2,}/;
+var SENTENCE = /(?<=[.!?])\s+/;
+function splitPassages(content, maxWords) {
+  const text = (_nullishCoalesce(content, () => ( ""))).trim();
+  if (words(text).length <= maxWords) return text ? [text] : [];
+  const out = [];
+  const lines = text.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      let j2 = i + 1;
+      while (j2 < lines.length && !FENCE.test(lines[j2])) j2 += 1;
+      out.push(...windowsOf(lines.slice(i + 1, j2), maxWords));
+      i = j2 + 1;
+      continue;
+    }
+    if (line.trim().startsWith("|")) {
+      let j2 = i;
+      while (j2 < lines.length && lines[j2].trim().startsWith("|")) j2 += 1;
+      const rows = lines.slice(i, j2).filter((r) => !TABLE_RULE.test(r)).map((r) => r.trim());
+      const [header, body] = rows.length > 1 ? [rows[0], rows.slice(1)] : ["", rows];
+      for (const row of body) {
+        const both = `${header} ${row}`.trim();
+        out.push(words(both).length <= Math.trunc(maxWords * 3 / 2) ? both : row);
+      }
+      i = j2;
+      continue;
+    }
+    let j = i;
+    while (j < lines.length && lines[j].trim() && !FENCE.test(lines[j]) && !lines[j].trim().startsWith("|")) j += 1;
+    if (j === i) {
+      i += 1;
+      continue;
+    }
+    const block = lines.slice(i, j);
+    if (block.length > 1 && block.every((b) => words(b).length <= 25)) {
+      out.push(...windowsOf(block, maxWords));
+    } else {
+      const sentences = block.map((b) => b.trim()).join(" ").split(SENTENCE).filter((x) => x.trim());
+      out.push(...windowsOf(sentences, maxWords));
+    }
+    i = j;
+  }
+  const kept = out.filter((x) => x.trim());
+  return kept.length ? kept : [text];
+}
+function windowsOf(pieces, maxWords) {
+  const out = [];
+  let cur = [];
+  let used = 0;
+  for (const raw of pieces) {
+    const piece = raw.trim();
+    if (!piece) continue;
+    const n2 = words(piece).length;
+    if (cur.length && used + n2 > maxWords) {
+      out.push(cur.join(" "));
+      cur = [];
+      used = 0;
+    }
+    if (n2 > maxWords) {
+      const w = words(piece);
+      for (let k = 0; k < w.length; k += maxWords) out.push(w.slice(k, k + maxWords).join(" "));
+      continue;
+    }
+    cur.push(piece);
+    used += n2;
+  }
+  if (cur.length) out.push(cur.join(" "));
+  return out;
+}
+function askedKinds(query) {
+  const out = [];
+  for (const [name, spec] of Object.entries(_nullishCoalesce(_chunkICUFS3B5cjs.HISTORY_SEARCH.asked_kinds, () => ( {})))) {
+    if (name.startsWith("$") || typeof spec !== "object") continue;
+    if (new RegExp(spec.query, "i").test(_nullishCoalesce(query, () => ( "")))) out.push(new RegExp(spec.value));
+  }
+  return out;
+}
+function asksHowItStarted(query) {
+  const spec = _chunkICUFS3B5cjs.HISTORY_SEARCH.early_query;
+  if (!_optionalChain([spec, 'optionalAccess', _67 => _67.pattern])) return false;
+  return new RegExp(spec.pattern, (_nullishCoalesce(spec.flags, () => ( ""))).includes("i") ? "i" : "").test(_nullishCoalesce(query, () => ( "")));
+}
+async function searchTurns(turns, query, options = {}) {
+  const params = _chunkICUFS3B5cjs.HISTORY_SEARCH;
+  const k = params.max_excerpts;
+  const skip = new Set(_nullishCoalesce(options.exclude, () => ( [])));
+  const pool = turns.filter((t) => t.content && !skip.has(t.content) && !skip.has(_nullishCoalesce(t.message_id, () => ( ""))));
+  const terms = new Set(tokenize2(query || ""));
+  const literals = literalsOf(query);
+  if (pool.length === 0 || terms.size === 0 && literals.length === 0 && !options.encoder) return [];
+  const maxWords = params.max_words_per_excerpt;
+  const units = [];
+  pool.forEach((t, ti) => {
+    if (!params.passages) {
+      units.push({ seq: t.seq, content: t.content, turn: ti, first: true, last: true, part: -1 });
+      return;
+    }
+    const parts = splitPassages(t.content, maxWords);
+    parts.forEach((part, pi) => {
+      units.push({
+        seq: t.seq,
+        content: part,
+        turn: ti,
+        first: pi === 0,
+        last: pi === parts.length - 1,
+        part: parts.length > 1 ? pi : -1
+      });
+    });
+  });
+  const docs = units.map((u) => tokenize2(u.content));
+  const bm = new (0, _chunkICUFS3B5cjs.BM25)(docs);
+  const termList = [...terms];
+  const rows = units.map((turn, i) => {
+    const held = new Set(docs[i]);
+    let matched = 0;
+    for (const t of terms) if (held.has(t)) matched += 1;
+    const low = turn.content.toLowerCase();
+    let literal = 0;
+    for (const lit of literals) if (low.includes(lit)) literal += 1;
+    return { i, bm25: matched ? bm.score(termList, i) : 0, matched, literal };
+  });
+  const need = Math.min(params.min_matched_terms, Math.max(1, terms.size));
+  const rareCap = Math.max(1, Math.trunc((_nullishCoalesce(params.rare_term_max_share, () => ( 0))) * units.length));
+  const rare = /* @__PURE__ */ new Set();
+  for (const t of terms) {
+    let n3 = 0;
+    for (const doc of docs) if (doc.includes(t)) n3 += 1;
+    if (n3 > 0 && n3 <= rareCap) rare.add(t);
+  }
+  let eligible;
+  if (params.passages) {
+    const turnTerms = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const held = _nullishCoalesce(turnTerms.get(units[r.i].turn), () => ( /* @__PURE__ */ new Set()));
+      for (const t of docs[r.i]) if (terms.has(t)) held.add(t);
+      turnTerms.set(units[r.i].turn, held);
+    }
+    eligible = rows.filter(
+      (r) => r.literal > 0 || r.matched > 0 && (turnTerms.get(units[r.i].turn).size >= need || docs[r.i].some((t) => rare.has(t)))
+    );
+  } else {
+    eligible = rows.filter(
+      (r) => r.literal > 0 || r.matched >= need || r.matched > 0 && docs[r.i].some((t) => rare.has(t))
+    );
+  }
+  const rrf = params.rrf_k;
+  const fused = /* @__PURE__ */ new Map();
+  const via = /* @__PURE__ */ new Map();
+  for (const r of eligible) fused.set(r.i, 0);
+  const add = (i, rank, how) => {
+    fused.set(i, (_nullishCoalesce(fused.get(i), () => ( 0))) + 1 / (rrf + rank + 1));
+    if (!via.has(i)) via.set(i, how);
+  };
+  eligible.filter((r) => r.literal > 0).sort((a, b) => b.literal - a.literal || a.i - b.i).forEach((r, rank) => add(r.i, rank, "literal"));
+  eligible.filter((r) => r.bm25 > 0).sort((a, b) => b.bm25 - a.bm25 || a.i - b.i).forEach((r, rank) => add(r.i, rank, "bm25"));
+  const kinds = askedKinds(query);
+  if (kinds.length) {
+    rows.filter((r) => r.matched > 0 && kinds.some((k2) => k2.test(units[r.i].content))).sort((a, b) => b.bm25 - a.bm25 || a.i - b.i).forEach((r, rank) => add(r.i, rank, "kind"));
+  }
+  if (options.encoder) {
+    const ranked2 = await embeddingRanks(units, query, options.encoder, _nullishCoalesce(options.store, () => ( null)), _nullishCoalesce(params.min_cosine, () => ( 0.4)));
+    ranked2.forEach(([i], rank) => add(i, rank, "embedding"));
+  }
+  if (fused.size === 0) return [];
+  const n2 = Math.max(pool.length - 1, 1);
+  const weight = asksHowItStarted(query) ? 0 : params.recency_weight;
+  const top = /* @__PURE__ */ new Map();
+  const ranked = /* @__PURE__ */ new Map();
+  for (const [u, v] of fused) {
+    const ti = units[u].turn;
+    const score = v + weight * (ti / n2) / (rrf + 1);
+    ranked.set(ti, [..._nullishCoalesce(ranked.get(ti), () => ( [])), [score, u]]);
+    const held = top.get(ti);
+    if (!held || score > held[0]) top.set(ti, [score, u]);
+  }
+  const best = [...top.keys()].sort((a, b) => top.get(b)[0] - top.get(a)[0] || a - b).slice(0, k);
+  const perTurn = _nullishCoalesce(params.passages_per_turn, () => ( 1));
+  const shown = (ti) => {
+    const unit = units[top.get(ti)[1]];
+    if (!params.passages || unit.first && unit.last) return excerptOf(pool[ti].content, terms, literals, maxWords);
+    const picked = [...ranked.get(ti)].sort((a, b) => b[0] - a[0] || b[1] - a[1]).slice(0, perTurn).map(([, u]) => u).sort((a, b) => a - b);
+    const parts = [];
+    for (const u of picked) parts.push((units[u].first || parts.length ? "" : "... ") + units[u].content);
+    return parts.join(" ... ") + (units[picked[picked.length - 1]].last ? "" : " ...");
+  };
+  const found = /* @__PURE__ */ new Map();
+  for (const ti of best) {
+    found.set(ti, {
+      position: pool[ti].position,
+      role: pool[ti].role,
+      timestamp: pool[ti].timestamp,
+      score: top.get(ti)[0],
+      via: _nullishCoalesce(via.get(top.get(ti)[1]), () => ( "")),
+      text: shown(ti)
+    });
+  }
+  const before2 = _nullishCoalesce(params.previous_turns, () => ( 0));
+  const tail = _nullishCoalesce(params.previous_turn_words, () => ( 40));
+  for (const i of best) {
+    for (let j = i - before2; j < i; j++) {
+      if (j < 0 || found.has(j)) continue;
+      const hit = pool[i].position;
+      const prev = pool[j].position;
+      if (hit && prev && hit - prev > before2) continue;
+      const w = words(pool[j].content);
+      found.set(j, {
+        position: prev,
+        role: pool[j].role,
+        timestamp: pool[j].timestamp,
+        score: 0,
+        via: "previous",
+        text: w.length <= tail ? w.join(" ") : "... " + w.slice(-tail).join(" ")
+      });
+    }
+  }
+  return [...found.keys()].sort((a, b) => a - b).map((i) => found.get(i));
+}
+async function embeddingRanks(pool, query, encoder, store, minCosine) {
+  const keyOf = (u) => (_nullishCoalesce(u.part, () => ( -1))) < 0 ? encoder.model : `${encoder.model}#p${u.part}`;
+  const vectors = /* @__PURE__ */ new Map();
+  if (store !== null) {
+    const byKey = /* @__PURE__ */ new Map();
+    pool.forEach((u, i) => byKey.set(keyOf(u), [..._nullishCoalesce(byKey.get(keyOf(u)), () => ( [])), i]));
+    for (const [key, idx] of byKey) {
+      const held = store.vectors(idx.map((i) => pool[i].seq), key);
+      for (const i of idx) {
+        const v = held.get(pool[i].seq);
+        if (v) vectors.set(i, v);
+      }
+    }
+  }
+  const missing = pool.map((_, i) => i).filter((i) => !vectors.has(i));
+  if (missing.length > 0) {
+    const fresh = await encoder.encode(missing.map((i) => pool[i].content));
+    const put = /* @__PURE__ */ new Map();
+    missing.forEach((i, j) => {
+      const v = Float32Array.from(_nullishCoalesce(fresh[j], () => ( [])));
+      vectors.set(i, v);
+      const key = keyOf(pool[i]);
+      put.set(key, (_nullishCoalesce(put.get(key), () => ( /* @__PURE__ */ new Map()))).set(pool[i].seq, v));
+    });
+    if (store) for (const [key, items] of put) store.putVectors(key, items);
+  }
+  const q = await _asyncNullishCoalesce((await (_nullishCoalesce(encoder.encodeQuery, () => ( encoder.encode))).call(encoder, [query]))[0], async () => ( []));
+  return pool.map((_, i) => [i, cosine(q, _nullishCoalesce(vectors.get(i), () => ( [])))]).filter(([, c]) => c >= minCosine).sort((a, b) => b[1] - a[1]);
+}
+function toolResultText(result, toolName) {
+  let text = typeof result === "string" ? result : _nullishCoalesce(JSON.stringify(result), () => ( String(result)));
+  const limit = _nullishCoalesce(_chunkICUFS3B5cjs.HISTORY_SEARCH.tool_result_max_chars, () => ( 16e3));
+  if (text.length > limit) text = text.slice(0, limit) + " ...[cut]";
+  return `[tool result: ${toolName || "tool"}] ${text}`;
+}
+function renderExcerpts(excerpts, latest = "") {
+  if (excerpts.length === 0) return "";
+  const lines = [_chunkICUFS3B5cjs.HISTORY_SEARCH.heading];
+  for (const e of excerpts) {
+    let where = e.position ? `turn ${e.position}, ${e.role}` : `${e.role}, earlier`;
+    if (e.timestamp) {
+      const ago = before(e.timestamp, latest);
+      where += `, ${e.timestamp}` + (ago ? ` (${ago})` : "");
+    }
+    lines.push(`- ${where}: "${e.text}"`);
+  }
+  return lines.join("\n");
+}
+var ZONED = /(?:Z|[+-]\d{2}:\d{2})$/;
+function instant(stamp) {
+  const text = (_nullishCoalesce(stamp, () => ( ""))).trim();
+  if (!ZONED.test(text)) return null;
+  const ms = Date.parse(text);
+  return Number.isNaN(ms) ? null : ms / 1e3;
+}
+function before(stamp, latest) {
+  const at = instant(stamp);
+  const now = instant(latest);
+  if (at === null || now === null || now < at) return "";
+  const seconds = Math.trunc(now - at);
+  for (const [unit, size] of [["day", 86400], ["hour", 3600], ["minute", 60]]) {
+    if (seconds >= size) {
+      const n2 = Math.trunc(seconds / size);
+      return `${n2} ${unit}${n2 !== 1 ? "s" : ""} before the latest message`;
+    }
+  }
+  return "less than a minute before the latest message";
+}
+
 // src/context/overlay.ts
 var MAX_TURNS = 20;
 var TOKEN_BUDGET = 2e3;
@@ -1885,7 +2804,23 @@ function overlayLocalRecentTurns(response, store, conversationId, configured) {
     if (entry === null) return;
     const existing = _nullishCoalesce(response.conversation_context, () => ( null));
     if (existing !== null && !verbatimOverlayEnabled(configured)) return;
-    const localTurns = budgetRecentTurns(entry.recentTurns);
+    const serverCompaction = existing === null ? null : existing["compaction_id"];
+    const localIsWhole = isComplete(entry) && (!serverCompaction || serverCompaction === entry.compactionId);
+    let sourceTurns = entry.recentTurns;
+    if (existing !== null && !localIsWhole) {
+      const raw = Array.isArray(existing["recent_turns"]) ? existing["recent_turns"] : [];
+      const serverTurns = raw.map((t) => ({
+        role: String(_nullishCoalesce(t["role"], () => ( "user"))),
+        content: String(_nullishCoalesce(t["content"], () => ( ""))),
+        timestamp: String(_nullishCoalesce(t["timestamp"], () => ( "")))
+      }));
+      sourceTurns = [...serverTurns, ...turnsAfter(entry.recentTurns, serverTurns)];
+    }
+    const localTurns = budgetRecentTurns(sourceTurns).map((t) => ({
+      role: t.role,
+      content: t.content,
+      timestamp: t.timestamp
+    }));
     const serverField = (name) => existing === null ? void 0 : existing[name];
     const orLocal = (name, local) => {
       const value = serverField(name);
@@ -1902,7 +2837,7 @@ function overlayLocalRecentTurns(response, store, conversationId, configured) {
       compacted_at: orLocal("compacted_at", entry.compactedAt),
       conversation_id: conversationId
     };
-  } catch (e10) {
+  } catch (e13) {
   }
 }
 
@@ -1915,7 +2850,7 @@ function stringify(value) {
   if (t === "string" || t === "number" || t === "boolean") return String(value);
   try {
     return _nullishCoalesce(JSON.stringify(value), () => ( ""));
-  } catch (e11) {
+  } catch (e14) {
     return String(value);
   }
 }
@@ -1940,14 +2875,28 @@ function buildRecentMessages(turns) {
     role: t.role || "user",
     content: _nullishCoalesce(t.content, () => ( "")),
     timestamp: t.timestamp,
-    message_id: `local-${idx}`
+    message_id: t.message_id || `local-${idx}`
   }));
 }
 function compactedMessageCount(_entry) {
   return 0;
 }
+function blockOf(entry) {
+  if (entry.contextBlock) return entry.contextBlock.trim();
+  if (entry.summary && entry.summary.startsWith(CONTEXT_BLOCK_PREFIX)) return entry.summary.trim();
+  return null;
+}
 function formatStructured(entry, recent) {
   const parts = [];
+  const block = blockOf(entry);
+  if (block) {
+    parts.push(block);
+    if (recent.length > 0) {
+      parts.push(`## Recent Turns (${recent.length})`);
+      for (const m of recent) parts.push(`**${m.role}**: ${m.content}`);
+    }
+    return parts.filter(Boolean).join("\n\n").trim();
+  }
   if (entry.summary) {
     parts.push("## Summary");
     parts.push(entry.summary.trim());
@@ -1982,9 +2931,11 @@ function formatStructured(entry, recent) {
 }
 function formatNarrative(entry, recent) {
   const parts = [];
-  if (entry.summary) parts.push(entry.summary.trim());
-  if (entry.conversationalParagraph) parts.push(entry.conversationalParagraph.trim());
-  else if (entry.factualParagraph) parts.push(entry.factualParagraph.trim());
+  const block = blockOf(entry);
+  if (block) parts.push(block);
+  else if (entry.summary) parts.push(entry.summary.trim());
+  if (!block && entry.conversationalParagraph) parts.push(entry.conversationalParagraph.trim());
+  else if (!block && entry.factualParagraph) parts.push(entry.factualParagraph.trim());
   if (recent.length > 0) {
     const tail = recent.map((m) => `${m.role}: ${m.content}`).join("\n");
     parts.push(`Recent exchanges:
@@ -1994,6 +2945,10 @@ ${tail}`);
 }
 function formatBullets(entry, recent) {
   const parts = [];
+  const block = blockOf(entry);
+  if (block) {
+    return [block, ...recent.map((m) => `- ${m.role}: ${m.content}`)].join("\n").trim();
+  }
   if (entry.summary) parts.push(`- Summary: ${entry.summary.trim()}`);
   for (const [k, v] of Object.entries(_nullishCoalesce(entry.currentState, () => ( {})))) {
     parts.push(`- ${k}: ${stringify(v)}`);
@@ -2031,7 +2986,9 @@ function renderForPrompt(entry, style = DEFAULT_STYLE, now = Date.now) {
     recent_messages: recent,
     recent_message_count: recent.length,
     compacted_message_count: compacted,
-    total_message_count: recent.length + compacted
+    total_message_count: recent.length + compacted,
+    context_block: blockOf(entry),
+    compaction_id: entry.compactionId
   };
 }
 function renderCompacted(entry, format = "structured", correlationId = "") {
@@ -2176,10 +3133,10 @@ function servedItemIds(hit) {
   }
   return ids;
 }
-function tryServeFromCache(cache, scope, params, maxItems) {
+async function tryServeFromCache(cache, scope, params, maxItems) {
   try {
     const scoped = scopeLookupParams(scope, params);
-    const hit = cache.lookup({
+    const hit = await cache.lookupAsync({
       searchQuery: _nullishCoalesce(scoped.searchQuery, () => ( null)),
       entityId: _nullishCoalesce(scoped.entityId, () => ( null)),
       customerId: _nullishCoalesce(scoped.customerId, () => ( null)),
@@ -2190,7 +3147,7 @@ function tryServeFromCache(cache, scope, params, maxItems) {
     });
     if (hit === null) return { response: null, hit: null };
     return { response: buildAnticipationResponse(hit), hit };
-  } catch (e12) {
+  } catch (e15) {
     return { response: null, hit: null };
   }
 }
@@ -2267,6 +3224,8 @@ function mergeScopeResults(scopeResults) {
     episodes: [],
     emotions: [],
     temporal_events: [],
+    items: [],
+    excerpts: [],
     scope_map: {},
     conversation_context: null,
     profile: null,
@@ -2276,6 +3235,8 @@ function mergeScopeResults(scopeResults) {
     total_items: 0,
     metadata: null
   };
+  const rankedSeen = /* @__PURE__ */ new Set();
+  const rankedItems = [];
   for (const [scopeName, response] of scopeResults) {
     out.scopes_queried.push(scopeName);
     if (out.metadata === null && response.metadata !== void 0) {
@@ -2300,8 +3261,32 @@ function mergeScopeResults(scopeResults) {
         out[collection].push(item);
       }
     }
+    const excerpts = response["excerpts"];
+    if (Array.isArray(excerpts)) {
+      for (const item of excerpts) {
+        const id = itemId2(item);
+        if (id !== void 0) {
+          if (seen.has(id)) continue;
+          seen.add(id);
+          out.scope_map[id] = scopeName;
+        }
+        out.excerpts.push(item);
+      }
+    }
+    const ranked = response["items"];
+    if (Array.isArray(ranked)) {
+      for (const item of ranked) {
+        const id = itemId2(item);
+        if (id !== void 0) {
+          if (rankedSeen.has(id)) continue;
+          rankedSeen.add(id);
+        }
+        rankedItems.push(item);
+      }
+    }
   }
-  out.total_items = ITEM_COLLECTIONS.reduce((n2, c) => n2 + out[c].length, 0);
+  out.items = sortByRankScore(rankedItems).map((item, n2) => ({ ...item, rank: n2 + 1 }));
+  out.total_items = ITEM_COLLECTIONS.reduce((n2, c) => n2 + out[c].length, 0) + out.excerpts.length;
   return out;
 }
 function oneDecimal(value) {
@@ -2327,7 +3312,18 @@ function formatForPrompt(ctx, options = {}) {
   const includeScope = _nullishCoalesce(options.includeScope, () => ( false));
   const includeConversationContext = _nullishCoalesce(options.includeConversationContext, () => ( true));
   const sections = [];
-  if (ctx.facts.length > 0) {
+  const ranked = _nullishCoalesce(ctx.items, () => ( []));
+  if (ranked.length > 0) {
+    const lines = ranked.map((it, n2) => {
+      let label = rankedLabel(String(_nullishCoalesce(it["category"], () => ( ""))));
+      if (includeScope) label += `, scope: ${scopeOf(ctx, it)}`;
+      return `${n2 + 1}. [${label}] ${String(_nullishCoalesce(it.content, () => ( "")))}`;
+    });
+    sections.push(`### Memories
+${lines.join("\n")}`);
+  }
+  const typed = ranked.length === 0;
+  if (typed && ctx.facts.length > 0) {
     const lines = ctx.facts.map((f) => {
       let line = `- ${String(_nullishCoalesce(f.content, () => ( "")))}`;
       if (includeScope) line += ` [scope: ${scopeOf(ctx, f)}]`;
@@ -2336,7 +3332,7 @@ function formatForPrompt(ctx, options = {}) {
     sections.push(`### Facts
 ${lines.join("\n")}`);
   }
-  if (ctx.preferences.length > 0) {
+  if (typed && ctx.preferences.length > 0) {
     const lines = ctx.preferences.map((p) => {
       const extras = [];
       if (includeScope) extras.push(`scope: ${scopeOf(ctx, p)}`);
@@ -2349,7 +3345,7 @@ ${lines.join("\n")}`);
     sections.push(`### Preferences
 ${lines.join("\n")}`);
   }
-  if (ctx.episodes.length > 0) {
+  if (typed && ctx.episodes.length > 0) {
     const lines = ctx.episodes.map((e) => {
       let line = `- ${String(_nullishCoalesce(e["summary"], () => ( "")))}`;
       if (includeScope) line += ` [scope: ${scopeOf(ctx, e)}]`;
@@ -2358,7 +3354,7 @@ ${lines.join("\n")}`);
     sections.push(`### Episodes
 ${lines.join("\n")}`);
   }
-  if (ctx.emotions.length > 0) {
+  if (typed && ctx.emotions.length > 0) {
     const lines = ctx.emotions.map((em) => {
       const extras = [];
       if (includeScope) extras.push(`scope: ${scopeOf(ctx, em)}`);
@@ -2372,7 +3368,7 @@ ${lines.join("\n")}`);
     sections.push(`### Emotions
 ${lines.join("\n")}`);
   }
-  if (ctx.temporal_events.length > 0) {
+  if (typed && ctx.temporal_events.length > 0) {
     const lines = ctx.temporal_events.map((te) => {
       const extras = [];
       if (includeScope) extras.push(`scope: ${scopeOf(ctx, te)}`);
@@ -2626,7 +3622,10 @@ function buildTool(target, options = {}, onWarning = () => {
 }
 
 // src/client.ts
-var SynapClient = class {
+function localModelOff() {
+  return ["off", "0", "false", "no", "none"].includes((_nullishCoalesce(_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_SDK_LOCAL_MODEL"), () => ( ""))).trim().toLowerCase());
+}
+var SynapClient = (_class4 = class _SynapClient {
   // Native-private (`#`), not TypeScript `private`. TS `private` is erased at
   // compile time, so the field stays enumerable at runtime and a JS consumer
   // can still reach it. These two were public and made `client.transport
@@ -2652,7 +3651,16 @@ var SynapClient = class {
   #registryKeys;
   #compactionSubscribers;
   #shortTerm;
+  /** Every raw turn, past compaction, for local history search. */
+  #turnStore;
+  /** A local embedding model for history search; null = keywords only. */
+  #localEncoder = null;
+  /** `history_search_model`: "auto", an "onnx:..." name, or null for none. */
+  #localModelName = "auto";
+  #localModelStarted = false;
+  #backfillAfter = /* @__PURE__ */ new Map();
   #stVerbatimOverlay;
+  #agentModel = {};
   #logger;
   #stAuthoritative;
   #turns;
@@ -2690,13 +3698,13 @@ var SynapClient = class {
       userAgent: `@maximem/synap-js-sdk/${SDK_VERSION}`
     });
     if (options.heartbeat) this.#transport.startHeartbeat();
-    this.#anticipationCache = new (0, _chunkT6U5PVADcjs.AnticipationCache)();
+    this.#anticipationCache = new (0, _chunkICUFS3B5cjs.AnticipationCache)();
     this.#fetchHooks = {
-      beforeFetch: (scope, options2) => {
+      beforeFetch: async (scope, options2) => {
         const o2 = options2;
         if (_nullishCoalesce(o2["query_date"], () => ( o2["queryDate"]))) return null;
         if (_nullishCoalesce(o2["max_results_per_query"], () => ( o2["maxResultsPerQuery"]))) return null;
-        const attempt = tryServeFromCache(
+        const attempt = await tryServeFromCache(
           this.#anticipationCache,
           scope,
           {
@@ -2710,7 +3718,7 @@ var SynapClient = class {
             // on entity and conversation alone, so a bundle prefetched for one
             // rung answered a caller standing at another, entirely inside this
             // process and invisible to every server log.
-            scopeRung: _chunkT6U5PVADcjs.rungKey.call(void 0, 
+            scopeRung: _chunkICUFS3B5cjs.rungKey.call(void 0, 
               _nullishCoalesce(o2["scope_path"], () => ( o2["scopePath"]))
             )
           },
@@ -2720,7 +3728,9 @@ var SynapClient = class {
         return {
           response: attempt.response,
           servedItemIds: servedItemIds(attempt.hit),
-          bundleId: _nullishCoalesce(attempt.hit.bundleIds[0], () => ( ""))
+          bundleId: _nullishCoalesce(attempt.hit.bundleIds[0], () => ( "")),
+          borderline: attempt.hit.band === "borderline",
+          raceDeadlineMs: _chunkICUFS3B5cjs.SEMANTIC_MATCH.race_deadline_ms
         };
       },
       onAssembled: (scope, options2, response, startedAt) => {
@@ -2735,9 +3745,19 @@ var SynapClient = class {
     this.client = { context: { fetch: async (o2 = {}) => fetchContext(this.#transport, "client", o2, this.#fetchHooks) } };
     this.#compactionSubscribers = new CompactionSubscribers();
     this.#shortTerm = new ShortTermStore();
+    this.#turnStore = new TurnStore();
+    this.#shortTerm.attachArchive(this.#turnStore);
     this.#stVerbatimOverlay = _nullishCoalesce(options.st_verbatim_overlay, () => ( options.stVerbatimOverlay));
+    this.#agentModel = {
+      model: _nullishCoalesce(options.agent_model, () => ( options.agentModel)),
+      contextWindow: _nullishCoalesce(options.agent_context_window, () => ( options.agentContextWindow))
+    };
     this.#logger = options.logger;
     this.#stAuthoritative = _nullishCoalesce(options.sdk_st_authoritative, () => ( options.sdkStAuthoritative));
+    this.#localEncoder = _nullishCoalesce(_nullishCoalesce(options.history_search_encoder, () => ( options.historySearchEncoder)), () => ( null));
+    const modelOption = options.history_search_model !== void 0 ? options.history_search_model : options.historySearchModel;
+    this.#localModelName = modelOption === void 0 ? "auto" : modelOption;
+    if (_optionalChain([this, 'access', _68 => _68.#localEncoder, 'optionalAccess', _69 => _69.model]) === _chunkICUFS3B5cjs.SEMANTIC_MATCH.model) this.#anticipationCache.setEncoder(this.#localEncoder);
     this.#turns = new TurnCounter();
     this.conversation = createConversationNamespace(
       this.#transport,
@@ -2754,17 +3774,24 @@ var SynapClient = class {
       },
       // 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);
+      ({ conversationId, role, content, timestamp, messageId, serverMessageCount, inFlight }) => {
+        this.#shortTerm.appendTurn(conversationId, role, content, timestamp, {
+          messageId,
+          serverMessageCount,
+          inFlight
+        });
       },
       (response, conversationId, userId, scopePath) => {
         overlayLocalRecentTurns(response, this.#shortTerm, conversationId, this.#stVerbatimOverlay);
-        this.#injectUserSummary(response, conversationId, userId, _chunkT6U5PVADcjs.rungKey.call(void 0, scopePath));
+        this.#injectUserSummary(response, conversationId, userId, _chunkICUFS3B5cjs.rungKey.call(void 0, scopePath));
       },
       {
         prompt: (conversationId, style) => this.#localPrompt(conversationId, style),
-        compacted: (conversationId, format) => this.#localCompacted(conversationId, format)
-      }
+        compacted: (conversationId, format) => this.#localCompacted(conversationId, format),
+        reseed: (conversationId, response) => this.#reseedShortTerm(conversationId, response),
+        historyExcerpts: (conversationId, response, query) => this.#withHistoryExcerpts(conversationId, response, query)
+      },
+      () => this.#agentModel
     );
     this.memories = createMemoriesInterface(this.#transport, ({ userId, customerId }) => {
       for (const id of /* @__PURE__ */ new Set([userId, customerId])) {
@@ -2778,11 +3805,17 @@ var SynapClient = class {
       this.#anticipationCache,
       ({ conversationId, role, content }) => {
         this.#shortTerm.appendTurn(conversationId, role, content);
-      }
+      },
+      () => this.#agentModel,
+      ({ conversationId, result, toolName }) => this.archive_tool_result(conversationId, result, { tool_name: toolName })
     );
+    this.instance._internal.setOnListen(() => this.#startLocalModel());
     this.instance._internal.setCompactionApplier((bundle) => {
       this.#shortTerm.applyCompaction(bundle);
     });
+    this.instance._internal.setConversationStateHandler((conversationId, messageCount) => {
+      this.#shortTerm.noteServerCount(conversationId, messageCount);
+    });
     if (options._force_new !== true) {
       const incumbent = registerIfAbsent(registryKey, this);
       if (incumbent !== void 0) return incumbent;
@@ -2900,7 +3933,7 @@ var SynapClient = class {
           this.#registryKeys.push(resolvedInstanceId);
         }
       }
-    } catch (e13) {
+    } catch (e16) {
     }
   }
   /**
@@ -2942,6 +3975,14 @@ var SynapClient = class {
       this.#transport.setRetryPolicy(_nullishCoalesce(_nullishCoalesce(options.retryPolicy, () => ( options.retry_policy)), () => ( null)));
     }
     if (options.logger !== void 0) this.#logger = options.logger;
+    const model = _nullishCoalesce(options.agent_model, () => ( options.agentModel));
+    const window = _nullishCoalesce(options.agent_context_window, () => ( options.agentContextWindow));
+    if (model !== void 0 || window !== void 0) {
+      this.#agentModel = {
+        model: _nullishCoalesce(model, () => ( this.#agentModel.model)),
+        contextWindow: _nullishCoalesce(window, () => ( this.#agentModel.contextWindow))
+      };
+    }
   }
   /**
    * Fetch and merge context across every scope with an identifier, in one call.
@@ -2975,9 +4016,11 @@ var SynapClient = class {
       include_scope_labels: includeScopeLabels = false,
       context_mode: contextMode = "in-conversation",
       include_profile: includeProfile = true,
-      last_n_conversations: lastNConversations = 1
+      last_n_conversations: lastNConversations = 1,
+      response_shape: responseShape = "by_type"
     } = options;
     validateConversationId(conversationId);
+    responseShapeOf({ response_shape: responseShape });
     const wants = (scope) => scopes === void 0 || scopes.includes(scope);
     const shared = {
       search_query: searchQuery,
@@ -2989,7 +4032,8 @@ var SynapClient = class {
       // threaded three call sites by hand and missed the client branch, which
       // sits one indent deeper; spreading removes that whole class of miss.
       query_date: queryDate,
-      max_results_per_query: maxResultsPerQuery
+      max_results_per_query: maxResultsPerQuery,
+      response_shape: responseShape
     };
     const labels = [];
     const tasks = [];
@@ -3054,7 +4098,7 @@ var SynapClient = class {
         merged.conversation_context = await this.conversation.context.get_context_for_prompt({
           conversation_id: conversationId
         });
-      } catch (e14) {
+      } catch (e17) {
       }
     }
     merged.formatted_context = formatForPrompt(merged, {
@@ -3106,7 +4150,7 @@ var SynapClient = class {
         // not carry the caller's words.
         query_count: distinctQueryCount(_nullishCoalesce(options["search_query"], () => ( options["searchQuery"])))
       });
-    } catch (e15) {
+    } catch (e18) {
     }
   }
   /**
@@ -3131,7 +4175,7 @@ var SynapClient = class {
         }),
         scope
       });
-    } catch (e16) {
+    } catch (e19) {
     }
   }
   /**
@@ -3152,25 +4196,139 @@ var SynapClient = class {
   /**
    * Whether the SDK is authoritative for short-term context.
    *
-   * Resolution order matches Python's `_is_st_authoritative`: the explicit
-   * option first, then `SYNAP_SDK_ST_AUTHORITATIVE` (truthy strings only).
-   * Defaults to false, so nothing changes for a caller who never sets it.
+   * Resolution order matches Python's `_is_st_authoritative`:
+   * `SYNAP_SDK_ST_AUTHORITATIVE` first, as an explicit override in either
+   * direction, then the option. Off by default. Being enabled does not mean
+   * the local store is used: that also takes an entry that holds the whole
+   * conversation, see `isComplete`.
    */
   #isStAuthoritative() {
-    if (this.#stAuthoritative === true) return true;
     const raw = (_nullishCoalesce(_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_SDK_ST_AUTHORITATIVE"), () => ( ""))).trim().toLowerCase();
-    return ["1", "true", "yes", "on"].includes(raw);
+    if (["0", "false", "no", "off"].includes(raw)) return false;
+    if (["1", "true", "yes", "on"].includes(raw)) return true;
+    return this.#stAuthoritative === true;
   }
   /**
    * Render `get_context_for_prompt` from the local store, or null to fall
-   * through to the network. Warm means a compaction landed OR raw turns are
-   * buffered: with neither there is nothing to render and the server's answer
-   * is the only real one.
+   * through to the network.
+   *
+   * The store answers only when it holds the whole conversation: the server
+   * has confirmed a count the entry accounts for. An entry that is merely
+   * present is not enough. After a restart or an eviction it holds one turn,
+   * and rendering that as the conversation drops everything said before it.
+   */
+  /**
+   * `response` with the earlier turns that best match `query` (by default the
+   * latest user message) appended, when a compaction exists. The search runs
+   * here, over the turn archive. Python: `_with_history_excerpts`.
    */
+  async #withHistoryExcerpts(conversationId, response, query) {
+    const r = _nullishCoalesce(response, () => ( {}));
+    const store = this.#turnStore;
+    const recent = Array.isArray(r["recent_messages"]) ? r["recent_messages"] : [];
+    store.addMany(
+      conversationId,
+      recent.map((m) => ({
+        role: String(_nullishCoalesce(m["role"], () => ( "user"))),
+        content: String(_nullishCoalesce(m["content"], () => ( ""))),
+        timestamp: String(_nullishCoalesce(m["timestamp"], () => ( ""))),
+        message_id: typeof m["message_id"] === "string" ? m["message_id"] : null
+      }))
+    );
+    const entry = this.#shortTerm.get(conversationId);
+    const total = Math.max(Number(_nullishCoalesce(r["total_message_count"], () => ( 0))) || 0, Number(_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _70 => _70.serverMessageCount]), () => ( 0))) || 0);
+    this.#maybeBackfillTurns(conversationId, total);
+    if (!r["context_block"]) return response;
+    const turns = store.turns(conversationId);
+    let q = query;
+    if (!q) {
+      const latest = [...recent].reverse().find((m) => m["role"] === "user");
+      q = latest ? String(_nullishCoalesce(latest["content"], () => ( ""))) : _nullishCoalesce(_optionalChain([[...turns], 'access', _71 => _71.reverse, 'call', _72 => _72(), 'access', _73 => _73.find, 'call', _74 => _74((t) => t.role === "user"), 'optionalAccess', _75 => _75.content]), () => ( ""));
+    }
+    if (!q) return response;
+    const exclude = /* @__PURE__ */ new Set();
+    for (const m of recent) {
+      if (typeof m["message_id"] === "string" && m["message_id"]) exclude.add(m["message_id"]);
+      exclude.add(String(_nullishCoalesce(m["content"], () => ( ""))));
+    }
+    this.#startLocalModel();
+    const hits = await searchTurns(turns, q, { exclude, encoder: this.#localEncoder, store });
+    if (hits.length === 0) return response;
+    const block = renderExcerpts(hits, turns.length ? turns[turns.length - 1].timestamp : "");
+    return {
+      ...r,
+      history_excerpts: hits.map((h) => ({ position: h.position, role: h.role, text: h.text })),
+      history_block: block,
+      formatted_context: (String(_nullishCoalesce(r["formatted_context"], () => ( ""))).trimEnd() + "\n\n" + block).trim()
+    };
+  }
+  /**
+   * Keep what a tool returned in this process's turn archive, so history search
+   * can find it after a compaction. Never sent anywhere: the server's
+   * conversation holds what people said, and a compaction is made from that.
+   * `instance.record_tool_result` calls this too. Python: `archive_tool_result`.
+   */
+  archive_tool_result(conversationId, result, options = {}) {
+    if (!conversationId || result === null || result === void 0) return;
+    try {
+      this.#turnStore.add(
+        conversationId,
+        "tool",
+        toolResultText(result, _nullishCoalesce(options.tool_name, () => ( options.toolName))),
+        _nullishCoalesce(options.timestamp, () => ( (/* @__PURE__ */ new Date()).toISOString()))
+      );
+    } catch (e20) {
+    }
+  }
+  static __initStatic() {this.BACKFILL_COOLDOWN_MS = 6e4}
+  static __initStatic2() {this.BACKFILL_PAGE = 500}
+  /** Fetch, in the background, turns the server holds and the archive does not. */
+  /**
+   * Load the local embedding model in the background, once. Searches and
+   * lookups before it is ready match by words. Python: `_start_history_encoder`.
+   */
+  #startLocalModel() {
+    if (this.#localModelStarted) return;
+    this.#localModelStarted = true;
+    if (localModelOff()) return;
+    const name = this.#localModelName === "auto" ? _chunkICUFS3B5cjs.SEMANTIC_MATCH.model : this.#localModelName;
+    if (!name) return;
+    const callerEncoder = this.#localEncoder;
+    void Promise.resolve().then(() => _interopRequireWildcard(require("./onnx-encoder-4RSL6ID4.cjs"))).then(({ canRunLocalModel, loadOnnxEncoder }) => canRunLocalModel() ? loadOnnxEncoder(name) : null).then((encoder) => {
+      if (encoder === null) return;
+      if (callerEncoder === null) this.#localEncoder = encoder;
+      if (encoder.model === _chunkICUFS3B5cjs.SEMANTIC_MATCH.model) this.#anticipationCache.setEncoder(encoder);
+    }).catch(() => {
+    });
+  }
+  #maybeBackfillTurns(conversationId, total) {
+    if (total <= this.#turnStore.count(conversationId)) return;
+    const now = Date.now();
+    if (now < (_nullishCoalesce(this.#backfillAfter.get(conversationId), () => ( 0)))) return;
+    this.#backfillAfter.set(conversationId, now + _SynapClient.BACKFILL_COOLDOWN_MS);
+    void this.#backfillTurns(conversationId, total);
+  }
+  async #backfillTurns(conversationId, total) {
+    try {
+      let start = 1;
+      while (start <= total) {
+        const result = await this.#transport.request("conversation_turns", {
+          pathParams: { conversation_id: conversationId },
+          query: { start, limit: _SynapClient.BACKFILL_PAGE }
+        });
+        const page = _nullishCoalesce((_nullishCoalesce(result, () => ( {})))["turns"], () => ( []));
+        this.#turnStore.addMany(conversationId, page);
+        if (page.length < _SynapClient.BACKFILL_PAGE) break;
+        start += _SynapClient.BACKFILL_PAGE;
+      }
+    } catch (error) {
+      this.#warn(`Turn backfill for ${conversationId} failed: ${String(error)}`);
+    }
+  }
   #localPrompt(conversationId, style) {
     if (!this.#isStAuthoritative()) return null;
     const entry = this.#shortTerm.get(conversationId);
-    if (entry === null) return null;
+    if (entry === null || !isComplete(entry)) return null;
     if (entry.compactionId === null && entry.recentTurns.length === 0) return null;
     return renderForPrompt(entry, style);
   }
@@ -3178,9 +4336,29 @@ var SynapClient = class {
   #localCompacted(conversationId, format) {
     if (!this.#isStAuthoritative()) return null;
     const entry = this.#shortTerm.get(conversationId);
-    if (entry === null || entry.compactionId === null) return null;
+    if (entry === null || entry.compactionId === null || !isComplete(entry)) return null;
     return renderCompacted(entry, format);
   }
+  /**
+   * Bring the local store back in step from the server's answer.
+   *
+   * Only for a conversation this process writes to. The server's answer lists
+   * every message its summary does not cover, which is exactly what the entry
+   * was missing.
+   */
+  #reseedShortTerm(conversationId, response) {
+    if (!this.#isStAuthoritative()) return;
+    const entry = this.#shortTerm.get(conversationId);
+    if (entry === null || !entry.participant) return;
+    const r = _nullishCoalesce(response, () => ( {}));
+    const recent = Array.isArray(r["recent_messages"]) ? r["recent_messages"] : [];
+    this.#shortTerm.reseed(conversationId, {
+      compactionId: typeof r["compaction_id"] === "string" ? r["compaction_id"] : null,
+      recentMessages: recent,
+      compactedMessageCount: Number(_nullishCoalesce(r["compacted_message_count"], () => ( 0))) || 0,
+      totalMessageCount: Number(_nullishCoalesce(r["total_message_count"], () => ( 0))) || 0
+    });
+  }
   /** Every diagnostic the SDK emits passes through here. */
   #warn(message) {
     if (this.#logger !== void 0) {
@@ -3201,7 +4379,7 @@ var SynapClient = class {
     this.#transport.close();
     this.#anticipationCache.clear();
   }
-};
+}, _class4.__initStatic(), _class4.__initStatic2(), _class4);
 function pick3(o2, snake, camel) {
   const a = o2[snake];
   return a !== void 0 ? a : o2[camel];
@@ -3209,7 +4387,7 @@ function pick3(o2, snake, camel) {
 function resolveBaseUrl(options) {
   const explicit = _nullishCoalesce(options.baseUrl, () => ( options.api_base_url));
   if (explicit !== void 0) return explicit;
-  const fromEnv = _optionalChain([_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_BASE_URL"), 'optionalAccess', _54 => _54.trim, 'call', _55 => _55()]);
+  const fromEnv = _optionalChain([_chunkZKOJDUN4cjs.getEnv.call(void 0, "SYNAP_BASE_URL"), 'optionalAccess', _76 => _76.trim, 'call', _77 => _77()]);
   return fromEnv !== void 0 && fromEnv !== "" ? fromEnv : void 0;
 }
 function resolveCredentials(options) {
@@ -3277,5 +4455,11 @@ function resolveCredentials(options) {
 
 
 
-exports.ANY_SCOPE = _chunkT6U5PVADcjs.ANY_SCOPE; exports.AgentUnavailableError = _chunkT372OL3Qcjs.AgentUnavailableError; exports.AnticipationCache = _chunkT6U5PVADcjs.AnticipationCache; exports.AuthenticationError = _chunkT372OL3Qcjs.AuthenticationError; exports.BM25 = _chunkT6U5PVADcjs.BM25; exports.COMPACTION_LEVELS = COMPACTION_LEVELS; exports.CONTRACT = _chunkT6U5PVADcjs.CONTRACT; exports.ConflictError = _chunkT372OL3Qcjs.ConflictError; exports.ConnectionError = _chunkT372OL3Qcjs.ConnectionError; exports.ContextNotFoundError = _chunkT372OL3Qcjs.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.FORGET_MODES = FORGET_MODES; exports.HttpTransport = HttpTransport; exports.INGEST_MODES = INGEST_MODES; exports.ITEM_COLLECTIONS = ITEM_COLLECTIONS; exports.InsufficientCreditsError = _chunkT372OL3Qcjs.InsufficientCreditsError; exports.InvalidConversationIdError = _chunkT372OL3Qcjs.InvalidConversationIdError; exports.InvalidInputError = _chunkT372OL3Qcjs.InvalidInputError; exports.InvalidInstanceIdError = _chunkT372OL3Qcjs.InvalidInstanceIdError; exports.ListeningAlreadyActiveError = _chunkT372OL3Qcjs.ListeningAlreadyActiveError; exports.ListeningNotActiveError = _chunkT372OL3Qcjs.ListeningNotActiveError; exports.NetworkTimeoutError = _chunkT372OL3Qcjs.NetworkTimeoutError; exports.PermanentError = _chunkT372OL3Qcjs.PermanentError; exports.RateLimitError = _chunkT372OL3Qcjs.RateLimitError; exports.SDKError = _chunkT372OL3Qcjs.SDKError; exports.SDK_VERSION = SDK_VERSION; exports.ServiceUnavailableError = _chunkT372OL3Qcjs.ServiceUnavailableError; exports.SessionExpiredError = _chunkT372OL3Qcjs.SessionExpiredError; exports.SynapClient = SynapClient; exports.SynapError = _chunkT372OL3Qcjs.SynapError; exports.SynapPermanentError = _chunkT372OL3Qcjs.SynapPermanentError; exports.SynapTransientError = _chunkT372OL3Qcjs.SynapTransientError; exports.THRESHOLDS = _chunkT6U5PVADcjs.THRESHOLDS; exports.TranscriptConflictError = _chunkT372OL3Qcjs.TranscriptConflictError; exports.TransientError = _chunkT372OL3Qcjs.TransientError; exports.flattenContextItems = flattenContextItems; exports.formatForPrompt = formatForPrompt; exports.isOutcomeUnknown = isOutcomeUnknown; exports.isRecallQuery = _chunkT6U5PVADcjs.isRecallQuery; exports.isSynapError = _chunkT372OL3Qcjs.isSynapError; exports.mergeScopeResults = mergeScopeResults; exports.resolvePath = resolvePath; exports.shouldRetry = shouldRetry; exports.stem = _chunkT6U5PVADcjs.stem; exports.tokenize = _chunkT6U5PVADcjs.tokenize;
+
+
+
+
+
+
+exports.ANY_SCOPE = _chunkICUFS3B5cjs.ANY_SCOPE; exports.AgentUnavailableError = _chunkT372OL3Qcjs.AgentUnavailableError; exports.AnticipationCache = _chunkICUFS3B5cjs.AnticipationCache; exports.AuthenticationError = _chunkT372OL3Qcjs.AuthenticationError; exports.BM25 = _chunkICUFS3B5cjs.BM25; exports.COMPACTION_LEVELS = COMPACTION_LEVELS; exports.CONTRACT = _chunkICUFS3B5cjs.CONTRACT; exports.ConflictError = _chunkT372OL3Qcjs.ConflictError; exports.ConnectionError = _chunkT372OL3Qcjs.ConnectionError; exports.ContextNotFoundError = _chunkT372OL3Qcjs.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.EXCERPT_CATEGORY = EXCERPT_CATEGORY; exports.FORGET_MODES = FORGET_MODES; exports.HttpTransport = HttpTransport; exports.INGEST_MODES = INGEST_MODES; exports.ITEM_COLLECTIONS = ITEM_COLLECTIONS; exports.InsufficientCreditsError = _chunkT372OL3Qcjs.InsufficientCreditsError; exports.InvalidConversationIdError = _chunkT372OL3Qcjs.InvalidConversationIdError; exports.InvalidInputError = _chunkT372OL3Qcjs.InvalidInputError; exports.InvalidInstanceIdError = _chunkT372OL3Qcjs.InvalidInstanceIdError; exports.ListeningAlreadyActiveError = _chunkT372OL3Qcjs.ListeningAlreadyActiveError; exports.ListeningNotActiveError = _chunkT372OL3Qcjs.ListeningNotActiveError; exports.MEMORY_TYPES = MEMORY_TYPES; exports.NetworkTimeoutError = _chunkT372OL3Qcjs.NetworkTimeoutError; exports.PermanentError = _chunkT372OL3Qcjs.PermanentError; exports.RESPONSE_SHAPES = RESPONSE_SHAPES; exports.RateLimitError = _chunkT372OL3Qcjs.RateLimitError; exports.SDKError = _chunkT372OL3Qcjs.SDKError; exports.SDK_VERSION = SDK_VERSION; exports.ServiceUnavailableError = _chunkT372OL3Qcjs.ServiceUnavailableError; exports.SessionExpiredError = _chunkT372OL3Qcjs.SessionExpiredError; exports.SynapClient = SynapClient; exports.SynapError = _chunkT372OL3Qcjs.SynapError; exports.SynapPermanentError = _chunkT372OL3Qcjs.SynapPermanentError; exports.SynapTransientError = _chunkT372OL3Qcjs.SynapTransientError; exports.THRESHOLDS = _chunkICUFS3B5cjs.THRESHOLDS; exports.TranscriptConflictError = _chunkT372OL3Qcjs.TranscriptConflictError; exports.TransientError = _chunkT372OL3Qcjs.TransientError; exports.applyResponseShape = applyResponseShape; exports.flattenContextItems = flattenContextItems; exports.formatForPrompt = formatForPrompt; exports.isOutcomeUnknown = isOutcomeUnknown; exports.isRecallQuery = _chunkICUFS3B5cjs.isRecallQuery; exports.isSynapError = _chunkT372OL3Qcjs.isSynapError; exports.mergeScopeResults = mergeScopeResults; exports.rankItems = rankItems; exports.resolvePath = resolvePath; exports.shouldRetry = shouldRetry; exports.stem = _chunkICUFS3B5cjs.stem; exports.tokenize = _chunkICUFS3B5cjs.tokenize; exports.wireRankScore = wireRankScore;
 //# sourceMappingURL=index.cjs.map