@amaster.ai/dsh-storage 0.1.32 → 0.1.33

package/README.md

@@ -63,6 +63,26 @@ SQL Server note: Prisma's sqlserver connector has no `Json` type, so its variant
 
 Mirroring is a no-throw seam: backend errors are logged with a `[dsh-storage]` prefix and never escape into the agent loop.
 
+Successful native `compaction/end` events also write a `utility_compressor` message. Its
+`content` is the source-compatible `Content[]` JSON array of the complete surviving
+conversation: summary plus retained tail, with tool calls/results paired by ID. System
+prompts are excluded. The surface is captured at the event, before asynchronous database
+writes; failed/canceled compactions leave the previous snapshot intact. Snapshot rows do
+not increment the visible message count. Adjacent messages with the same role merge their
+ordered parts, since the legacy reader would otherwise skip the retained tail.
+
+Consumers can resume from the latest active compression snapshot plus later message rows.
+Snapshots and newly mirrored rows include `metadata.sessionCreatedAt` and `metadata.seq`
+to distinguish resumed session generations and messages in the same database second.
+Older snapshots without this metadata retain their creation-time boundary. The mirror
+does not fetch attachments or invent usable paths/URLs from opaque attachment IDs.
+Attachments, developer updates, extension blocks and non-object tool arguments are
+preserved as labelled JSON data in text parts when legacy `Content[]` cannot represent
+them natively. Such snapshots preserve reference information, not attachment bytes or a
+complete native session/tool registry. Attachment bytes still need their existing durable
+storage. An unchanged legacy reader remains timestamp-based; it must consume the sequence
+metadata to distinguish later messages in the same database second.
+
 ## Archive a session
 
 When handling a session-clear request, call `await ctx.get('dshStorage').archiveSession(sessionId)` after stopping the live turn. It waits for queued mirror writes, then transactionally assigns all current, non-deleted `ai_messages` rows (`history_id IS NULL`) to a non-deleted `ai_chat_histories` row. The returned history ID can be used to query those rows directly from the database; a second call with no active messages returns `null`. A database failure rejects this explicit operation instead of reporting a successful clear.

package/lib/compaction.js

@@ -0,0 +1,108 @@
+function recordedData(block) {
+    return { text: `[Recorded DSH ${block.type} data]\n${JSON.stringify(block)}` };
+}
+/** Legacy Content[] checkpoints remain readable by databaseChatStorage. */
+export function compressionSnapshot(session, event) {
+    if (event?.type !== 'compaction/end' || event.data?.error !== undefined)
+        return null;
+    const calls = new Map();
+    const messages = session.deriveMessages().flatMap((message) => {
+        if (message.role === 'system')
+            return [];
+        if (message.role === 'tool') {
+            const id = message.toolCallId ?? message.source?.callId;
+            const name = calls.get(id);
+            if (!name)
+                return [
+                    {
+                        role: 'user',
+                        parts: [
+                            recordedData({
+                                type: 'tool-result',
+                                toolCallId: id,
+                                content: message.content,
+                                isError: Boolean(message.isError),
+                            }),
+                        ],
+                    },
+                ];
+            return [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id,
+                                name,
+                                response: { output: message.content, isError: Boolean(message.isError) },
+                            },
+                        },
+                    ],
+                },
+            ];
+        }
+        const parts = message.content.map((block, index) => {
+            if (message.role === 'developer')
+                return recordedData(block);
+            switch (block.type) {
+                case 'text':
+                    return { text: block.text };
+                case 'reasoning': {
+                    const replay = message.source?.replayState?.blocks?.[index];
+                    const signature = replay?.signature ?? replay?.thoughtSignature;
+                    return {
+                        text: block.text,
+                        thought: true,
+                        ...(signature ? { thoughtSignature: signature } : {}),
+                    };
+                }
+                case 'tool-call': {
+                    calls.delete(block.id);
+                    let args;
+                    try {
+                        args = block.arguments ? JSON.parse(block.arguments) : {};
+                    }
+                    catch {
+                        return recordedData(block);
+                    }
+                    if (!args || typeof args !== 'object' || Array.isArray(args))
+                        return recordedData(block);
+                    calls.set(block.id, block.name);
+                    return {
+                        functionCall: { id: block.id, name: block.name, args },
+                    };
+                }
+                default:
+                    return recordedData(block);
+            }
+        });
+        return [{ role: message.role === 'assistant' ? 'model' : 'user', parts }];
+    });
+    const content = [];
+    for (const message of messages) {
+        const previous = content.at(-1);
+        // Legacy recovery discards adjacent equal roles instead of merging them.
+        if (previous && previous.role === message.role)
+            previous.parts.push(...message.parts);
+        else
+            content.push(message);
+    }
+    return {
+        id: event.data.compactionId,
+        sessionId: session.id,
+        historyId: null,
+        agentId: 'main',
+        type: 'utility_compressor',
+        content: JSON.stringify(content),
+        model: 'agent-history-provider-summarizer',
+        createdAt: new Date(event.time),
+        metadata: {
+            id: event.data.compactionId,
+            event: event.type,
+            seq: event.seq,
+            sessionCreatedAt: session.header?.createdAt,
+            sessionId: session.id,
+            newHistoryLength: content.length,
+        },
+    };
+}

package/lib/index.js

@@ -19,6 +19,7 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import { DatabaseBackend } from './backends/database.js';
+import { compressionSnapshot } from './compaction.js';
 import { mergeToolResult, projectEvent, usageSampleOf } from './projector.js';
 export const name = 'dsh-storage';
 // Event-tap only: no hard service dependency. Add 'sessionPersistence' to
@@ -154,13 +155,29 @@ export function apply(ctx, config) {
     /* eslint-disable @typescript-eslint/no-explicit-any */
     ctx.on('session/event', (session, event) => {
         const sessionId = session?.id ?? 'unknown';
+        let snapshot;
+        try {
+            // Capture the committed surface now; queued writes must not observe later steps.
+            snapshot = compressionSnapshot(session, event);
+        }
+        catch (error) {
+            console.error('[dsh-storage] compaction snapshot error:', error);
+            return;
+        }
         enqueue(sessionId, async () => {
+            if (snapshot) {
+                await fanout((backend) => backend.upsertMessage(snapshot));
+                return;
+            }
             let accum = sessions.get(sessionId);
             if (!accum) {
                 accum = await seedAccum(sessionId);
                 sessions.set(sessionId, accum);
             }
             let row = projectEvent(session, event, sessionId);
+            if (row && session.header?.createdAt !== undefined) {
+                row.metadata = { ...row.metadata, sessionCreatedAt: session.header.createdAt };
+            }
             const storedRows = row || event?.type === 'tool/result'
                 ? await backends[0].readMessages(sessionId, row?.id)
                 : [];

package/lib/types/compaction.d.ts

@@ -0,0 +1,3 @@
+import type { MessageRow } from './types.js';
+/** Legacy Content[] checkpoints remain readable by databaseChatStorage. */
+export declare function compressionSnapshot(session: any, event: any): MessageRow | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-storage",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "Session storage mirror for DeepSeek Harness: projects the session event stream into MySQL/PostgreSQL/SQLite/SQL Server (ai_messages / ai_chat_histories) without replacing dsh's local persistence.",
   "type": "module",
   "main": "lib/index.js",
@@ -63,7 +63,7 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.5",
-    "@deepseek-ai/dsh-session": "0.2.1-rc.3",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.4",
     "@prisma/adapter-libsql": "^7.9.1",
     "@prisma/adapter-mariadb": "^7.9.1",
     "@prisma/adapter-mssql": "^7.9.1",