stratagate-dsh 0.2.46 → 0.2.48

package/dist/index.js

@@ -5735,6 +5735,7 @@ var StrataGateRuntime = class {
       batchStatus: batch.status,
       recorded: true,
       namespace,
+      retrievalSequence: batch.sequence,
       retrievedCount: batch.refs.size,
       retrievedMemories,
       incremented: eventIds.size + elementIds.size,
@@ -6484,7 +6485,8 @@ var StrataGateRuntime = class {
     if (responses.length > 0) await memory.recordSuccessfulModelResponses(responses);
   }
   batch(session, evidence, results, metadata = {}) {
-    const id = `batch_${++this.batchSequence}`;
+    const sequence = ++this.batchSequence;
+    const id = `batch_${sequence}`;
     const refs = new Map(evidence.map(({ ref, target }) => [ref, target]));
     const key = String(session.id);
     let sessionBatches = this.batches.get(key);
@@ -6492,7 +6494,7 @@ var StrataGateRuntime = class {
       sessionBatches = /* @__PURE__ */ new Map();
       this.batches.set(key, sessionBatches);
     }
-    sessionBatches.set(id, { id, refs, status: "unresolved" });
+    sessionBatches.set(id, { id, sequence, refs, status: "unresolved" });
     this.latestBatchIds.set(key, id);
     return { batchId: id, evidenceRefs: [...refs.keys()], results, ...metadata };
   }
@@ -7097,7 +7099,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 }
 
 // src/web.ts
-var STRATAGATE_DSH_VERSION = "0.2.36";
+var STRATAGATE_DSH_VERSION = "0.2.48";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -7152,23 +7154,32 @@ function sourceMessages(snapshot, ids) {
   }
   return output;
 }
+function withLayerMetrics(layers) {
+  const tokenCounts = new Map(layers.map(({ level, content }) => [level, estimateTokens(content)]));
+  const l5Tokens = tokenCounts.get(5) ?? 0;
+  return layers.map((layer) => {
+    const tokens = tokenCounts.get(layer.level) ?? 0;
+    const percentOfL5 = layer.level === 5 ? 100 : l5Tokens > 0 ? Math.round(tokens / l5Tokens * 100) : 0;
+    return { ...layer, tokens, percentOfL5 };
+  });
+}
 function blockLayers(block) {
   if (block.processingStatus !== "ready" || !block.l0Title || !block.l0Tags || !block.l1Summary || !block.l2Keypoints) {
-    return [
+    return withLayerMetrics([
       { level: 3, content: block.l3Condensed },
       { level: 4, content: block.l4Readable },
       { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
-    ];
+    ]);
   }
-  return [
+  return withLayerMetrics([
     { level: 0, content: `${block.l0Title}
-\u6807\u7B7E\uFF1A${block.l0Tags.join("\u3001") || "\u65E0"}` },
+Tags: ${block.l0Tags.join(", ") || "none"}` },
     { level: 1, content: block.l1Summary || block.l0Title },
-    { level: 2, content: block.l2Keypoints.map((point) => `\u2022 ${point}`).join("\n") || block.l1Summary || block.l0Title },
+    { level: 2, content: block.l2Keypoints.map((point) => `- ${point}`).join("\n") || block.l1Summary || block.l0Title },
     { level: 3, content: block.l3Condensed || block.l2Keypoints.join("\n") || block.l1Summary },
     { level: 4, content: block.l4Readable || block.l3Condensed },
     { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
-  ];
+  ]);
 }
 function eventSummary(event) {
   return {
@@ -7391,6 +7402,15 @@ function receiptThreadId(id) {
   const match = /^dsh:(.+):turn:\d+$/.exec(id);
   return match?.[1]?.trim() || null;
 }
+function receiptTurnNumber(id) {
+  const match = /^dsh:(.+):turn:(\d+)$/.exec(id);
+  if (!match) return null;
+  const turn = Number(match[2]);
+  return Number.isSafeInteger(turn) ? turn : null;
+}
+function receiptTurnKey(threadId, createdAt) {
+  return `${threadId}\0${timestampKey(createdAt)}`;
+}
 function timestampKey(value) {
   const parsed = Date.parse(value);
   return Number.isFinite(parsed) ? String(parsed) : value;
@@ -7398,11 +7418,14 @@ function timestampKey(value) {
 function recoverSnapshotView(snapshot) {
   const receiptThreads = /* @__PURE__ */ new Map();
   const receiptActivity = /* @__PURE__ */ new Map();
+  const receiptTurns = /* @__PURE__ */ new Map();
   const receiptCandidates = /* @__PURE__ */ new Map();
   for (const receipt of snapshot.ingestionReceipts) {
     const threadId = receiptThreadId(receipt.id);
     if (!threadId) continue;
     receiptThreads.set(receipt.id, threadId);
+    const turn = receiptTurnNumber(receipt.id);
+    if (turn !== null) receiptTurns.set(receiptTurnKey(threadId, receipt.createdAt), turn);
     const currentActivity = receiptActivity.get(threadId);
     if (!currentActivity || receipt.createdAt > currentActivity) receiptActivity.set(threadId, receipt.createdAt);
     const key = timestampKey(receipt.createdAt);
@@ -7447,8 +7470,10 @@ function recoverSnapshotView(snapshot) {
   const turnCounters = /* @__PURE__ */ new Map();
   for (const block of blocks) {
     if (block.source.threadId) {
-      block.turnRange = [block.source.startTurn, block.source.endTurn];
-      turnCounters.set(block.threadId, Math.max(turnCounters.get(block.threadId) ?? 0, block.source.endTurn));
+      const turnMessages = block.messages.filter(({ role }) => role === "user");
+      const dshTurns = turnMessages.map((message) => receiptTurns.get(receiptTurnKey(block.threadId, message.createdAt)));
+      block.turnRange = dshTurns.length > 0 && dshTurns.every((turn) => turn !== void 0) ? [Math.min(...dshTurns), Math.max(...dshTurns)] : [block.source.startTurn, block.source.endTurn];
+      turnCounters.set(block.threadId, Math.max(turnCounters.get(block.threadId) ?? 0, block.turnRange[1]));
       continue;
     }
     const turns = Math.max(1, block.messages.filter(({ role }) => role === "user").length);
@@ -7460,7 +7485,8 @@ function recoverSnapshotView(snapshot) {
     blocks,
     openMessages: recoverMessages(snapshot.openTail),
     receiptThreads,
-    receiptActivity
+    receiptActivity,
+    receiptTurns
   };
 }
 function virtualBlockLayers(block) {
@@ -7471,14 +7497,14 @@ function virtualBlockLayers(block) {
   const title = firstUser?.content.replace(/\s+/g, " ").trim().slice(0, 80) || "\u65E7\u4F1A\u8BDD\u7247\u6BB5";
   const summary = natural.map(({ content }) => content.replace(/\s+/g, " ").trim()).filter(Boolean).join(" ").slice(0, 500);
   const keypoints = natural.filter(({ role }) => role === "user").map(({ content }) => content.replace(/\s+/g, " ").trim().slice(0, 160));
-  return [
+  return withLayerMetrics([
     { level: 0, content: title },
     { level: 1, content: summary || title },
     { level: 2, content: keypoints.map((point) => `\u2022 ${point}`).join("\n") || summary || title },
     { level: 3, content: deterministic.l3Condensed },
     { level: 4, content: deterministic.l4Readable },
     { level: 5, content: block.messages.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
-  ];
+  ]);
 }
 function conversationRows(snapshot, view = recoverSnapshotView(snapshot)) {
   const ids = /* @__PURE__ */ new Set([
@@ -7557,7 +7583,10 @@ async function memories(runtime, url) {
     const scopedBlocks = activeThreadId ? recovered.blocks.filter((block) => block.threadId === activeThreadId) : [];
     values = scopedBlocks.map((block) => {
       const source = block.source;
+      const layers = virtualBlockLayers(block);
+      const layerTokens = layers.map(({ level, tokens, percentOfL5 }) => ({ level, tokens, percentOfL5 }));
       const extraction = snapshot.extractionJobs.find(({ blockId }) => blockId === source.id);
+      const summary = snapshot.summaryJobs.find(({ blockId }) => blockId === source.id);
       const blockMessageIds = new Set(block.messages.map(({ id }) => id));
       const relatedEvents = snapshot.events.filter((event) => event.sourceBlockId === source.id && (!block.virtual || event.sourceMessageIds.some((id) => blockMessageIds.has(id))));
       const eventIds = new Set(relatedEvents.map(({ id }) => id));
@@ -7575,23 +7604,37 @@ async function memories(runtime, url) {
         latestBlockPosition,
         snapshot.blockDecayLambda
       );
+      const currentMetrics = layerTokens.find(({ level }) => level === currentLevel);
+      const l5Tokens = layerTokens.find(({ level }) => level === 5)?.tokens ?? 0;
       return {
         id: block.id,
         sourceBlockId: source.id,
         threadId: block.threadId,
         sequence: source.sequence,
+        blockIndex: blockPosition,
         turnRange: block.turnRange,
         title: block.virtual && block.messages.length !== source.l5Raw.length ? block.messages.find(({ role }) => role === "user")?.content.replace(/\s+/g, " ").trim().slice(0, 80) || "\u65E7\u4F1A\u8BDD\u7247\u6BB5" : source.l0Title,
         tags: source.l0Tags,
         summary: source.l1Summary,
         keypoints: source.l2Keypoints,
         currentLevel,
+        currentTokens: currentMetrics?.tokens ?? 0,
+        l5Tokens,
+        compressionPercent: currentMetrics?.percentOfL5 ?? (currentLevel === 5 ? 100 : 0),
+        layerTokens,
         distanceFromLatest: Math.max(0, latestBlockPosition - blockPosition),
         expansionSource: source.lastLiftedAt ? source.lastLiftedBy ?? "legacy" : null,
         lastLiftedAt: source.lastLiftedAt,
         sourceMessages: block.messages.length,
         createdAt: source.createdAt,
         virtual: block.virtual,
+        processingStatus: source.processingStatus,
+        summaryJob: summary ? {
+          status: summary.status,
+          attempts: summary.attempts,
+          nextRetryAt: summary.nextRetryAt,
+          updatedAt: summary.updatedAt
+        } : null,
         status,
         eventExtraction: extraction ? {
           status: extraction.status,
@@ -7612,6 +7655,7 @@ async function memories(runtime, url) {
     const latestSealedTurn = scopedBlocks.reduce((latest, block) => Math.max(latest, block.turnRange[1]), 0);
     const openMessages = activeThreadId ? recovered.openMessages.filter((message) => message.threadId === activeThreadId).map(({ message }) => message) : [];
     const openTurns = openMessages.filter(({ role }) => role === "user").length;
+    const openDshTurns = activeThreadId ? openMessages.filter(({ role }) => role === "user").map((message) => recovered.receiptTurns.get(receiptTurnKey(activeThreadId, message.createdAt))) : [];
     return {
       namespace,
       kind,
@@ -7620,10 +7664,13 @@ async function memories(runtime, url) {
       limit,
       items: filtered2.slice(offset, offset + limit),
       openBlock: {
-        turnRange: openTurns > 0 ? [latestSealedTurn + 1, latestSealedTurn + openTurns] : null,
+        turnRange: openTurns > 0 ? openDshTurns.length > 0 && openDshTurns.every((turn) => turn !== void 0) ? [Math.min(...openDshTurns), Math.max(...openDshTurns)] : [latestSealedTurn + 1, latestSealedTurn + openTurns] : null,
         messages: openMessages.length,
+        turns: openTurns,
+        capacity: snapshot.blockTurnSize,
         status: "open"
       },
+      blockTurnSize: snapshot.blockTurnSize,
       conversations,
       activeThreadId
     };