@amaster.ai/dsh-storage 0.1.14 → 0.1.15

package/README.md

@@ -53,6 +53,8 @@ npx prisma db push --schema node_modules/@amaster.ai/dsh-storage/prisma/schema.m
 
 The logical message id rides in `metadata.id`; message rows use a deterministic hash of `(session_id, message id)` as their primary key, so re-projected events upsert in place rather than duplicate — on every connector. Session rows are matched by `session_id` and keep their cuid primary keys. One deviation from the source project: no `user_id` column — tenancy rides on `session_id`.
 
+For `user/message` rows, `content` remains the text projection, while `metadata.message` retains the original user message as received, including `source` and ordered content blocks. Image/file blocks keep whatever attachment reference, path, URL, or inline data the incoming message actually contains; this mirror does not fetch or rewrite attachments. Re-projection writes the same raw message into the existing row.
+
 The `tool_calls` array retains dsh's tool-call blocks (`id`, `name`, `arguments`); the matching entry gains the structured `result` block and, on failure, an `error` identity. The plugin reads persisted model rows to match results across process restarts and upserts the same row ID, so duplicate results do not add rows or increment the session's message count. Existing historical `type=tool` rows are left intact.
 
 When an assistant message contains dsh `reasoning` blocks, `thoughts` is an array of `{ content }` entries in block order. If the adapter supplies a matching signature in the message's `source.replayState.blocks`, that entry also carries `thoughtSignature`. The full model `source`, including opaque `replayState`, is preserved in row metadata for lossless provider replay. The backend's `readMessages()` also accepts older `{ description }` entries and JSON string thoughts, returning them as `{ content }`. `subject` and a per-thought timestamp are not invented when the upstream message does not supply them.
@@ -61,6 +63,12 @@ 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.
 
+## 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.
+
+Archived rollups stay queryable. The plugin recognizes an active rollup as a history row with no associated messages, so the next projected event creates a fresh rollup instead of overwriting the archived one. The caller owns stopping/replacing the dsh session surface and any A2A task state; this operation only archives the database mirror.
+
 ## Compatibility
 
 Pinned dsh/cordis versions live in the [root compat matrix](../../README.md#compatibility). Event payloads ride pre-release dsh APIs — check the `TODO(verify)` markers in `src/` before upgrading dsh.

package/lib/backends/database.js

@@ -146,11 +146,13 @@ export class DatabaseBackend {
         if (!this.prisma)
             return [];
         // ponytail: tool-call lookup scans one session; add an indexed call lookup if that becomes slow.
+        // Scan only the active segment for tool results; exact-ID reads still find
+        // archived rows so redelivery does not count the same message twice.
         const rows = await this.prisma.aiMessage.findMany({
             where: {
                 sessionId,
                 deletedAt: null,
-                ...(messageId ? { id: pk(`message ${sessionId}\0${messageId}`) } : {}),
+                ...(messageId ? { id: pk(`message ${sessionId}\0${messageId}`) } : { historyId: null }),
             },
             orderBy: { createdAt: 'asc' },
         });
@@ -192,7 +194,7 @@ export class DatabaseBackend {
         if (!this.prisma)
             return null;
         const row = await this.prisma.aiChatHistory.findFirst({
-            where: { sessionId, deletedAt: null },
+            where: { sessionId, deletedAt: null, messages: { none: {} } },
         });
         if (!row)
             return null;
@@ -219,7 +221,7 @@ export class DatabaseBackend {
         // cuid primary key matches the source project and early-scaffold rows,
         // so existing data is continued, never duplicated.
         const existing = await this.prisma.aiChatHistory.findFirst({
-            where: { sessionId: row.sessionId, deletedAt: null },
+            where: { sessionId: row.sessionId, deletedAt: null, messages: { none: {} } },
             select: { id: true },
         });
         const data = {
@@ -238,6 +240,42 @@ export class DatabaseBackend {
             await this.prisma.aiChatHistory.create({ data });
         }
     }
+    async archiveSession(sessionId) {
+        if (!this.prisma)
+            throw new Error('dsh-storage database is not initialized');
+        return this.prisma.$transaction(async (tx) => {
+            const where = { sessionId, historyId: null, deletedAt: null };
+            const stats = await tx.aiMessage.aggregate({
+                where,
+                _count: { _all: true },
+                _min: { createdAt: true },
+                _max: { createdAt: true },
+            });
+            if (stats._count._all === 0)
+                return null;
+            // Active rollups have no attached messages; an archive gains them below.
+            const active = await tx.aiChatHistory.findFirst({
+                where: { sessionId, deletedAt: null, messages: { none: {} } },
+                select: { id: true },
+            });
+            const rollup = {
+                messageCount: stats._count._all,
+                firstMessageAt: stats._min.createdAt,
+                lastMessageAt: stats._max.createdAt,
+            };
+            const history = active
+                ? await tx.aiChatHistory.update({ where: { id: active.id }, data: rollup })
+                : await tx.aiChatHistory.create({
+                    data: { sessionId, ...rollup, totalTokens: 0n },
+                    select: { id: true },
+                });
+            const updated = await tx.aiMessage.updateMany({ where, data: { historyId: history.id } });
+            if (updated.count !== stats._count._all) {
+                throw new Error('active messages changed during archive');
+            }
+            return history.id;
+        });
+    }
     async close() {
         await this.prisma?.$disconnect?.();
     }

package/lib/index.js

@@ -136,6 +136,21 @@ export function apply(ctx, config) {
             await guard(async (backend) => backend.close?.());
         };
     });
+    ctx.provide('dshStorage', {
+        archiveSession(sessionId) {
+            // Join the same per-session chain as event writes, then discard the old
+            // in-memory rollup only after the database transaction commits.
+            const archived = (chains.get(sessionId) ?? started).then(async () => {
+                const id = await backends[0].archiveSession(sessionId);
+                sessions.delete(sessionId);
+                return id;
+            });
+            const settled = archived.then(() => { }, () => { });
+            chains.set(sessionId, settled);
+            track(settled);
+            return archived;
+        },
+    });
     /* eslint-disable @typescript-eslint/no-explicit-any */
     ctx.on('session/event', (session, event) => {
         const sessionId = session?.id ?? 'unknown';

package/lib/projector.js

@@ -77,7 +77,7 @@ export function projectEvent(_session, event, sessionId) {
                 id: message.id ?? randomUUID(),
                 type: 'user',
                 content: textOf(message),
-                metadata: { event: event.type, seq: event.seq },
+                metadata: { event: event.type, seq: event.seq, message },
             };
         }
         case 'assistant/message': {

package/lib/types/backends/database.d.ts

@@ -34,5 +34,6 @@ export declare class DatabaseBackend implements StorageBackend {
     readMessages(sessionId: string, messageId?: string): Promise<MessageRow[]>;
     readSession(sessionId: string): Promise<SessionRow | null>;
     upsertSession(row: SessionRow): Promise<void>;
+    archiveSession(sessionId: string): Promise<string | null>;
     close(): Promise<void>;
 }

package/lib/types/index.d.ts

@@ -53,4 +53,8 @@ export interface StoragePluginConfig {
         url: string;
     };
 }
+/** Explicit write API for a consumer's session-clear flow. */
+export interface DshStorageService {
+    archiveSession(sessionId: string): Promise<string | null>;
+}
 export declare function apply(ctx: Context, config: StoragePluginConfig): void;

package/lib/types/types.d.ts

@@ -47,5 +47,7 @@ export interface StorageBackend {
     readMessages(sessionId: string, messageId?: string): Promise<MessageRow[]>;
     upsertMessage(row: MessageRow): Promise<void>;
     upsertSession(row: SessionRow): Promise<void>;
+    /** Move active messages into a queryable history row; null when already empty. */
+    archiveSession(sessionId: string): Promise<string | null>;
     close?(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-storage",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "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",