@amaster.ai/dsh-storage 0.1.0

package/lib/generated/sqlserver/internal/prismaNamespaceBrowser.js

@@ -0,0 +1,90 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+import * as runtime from "@prisma/client/runtime/index-browser";
+export const Decimal = runtime.Decimal;
+export const NullTypes = {
+    DbNull: runtime.NullTypes.DbNull,
+    JsonNull: runtime.NullTypes.JsonNull,
+    AnyNull: runtime.NullTypes.AnyNull,
+};
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull;
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull;
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull;
+export const ModelName = {
+    AiMessage: 'AiMessage',
+    AiChatHistory: 'AiChatHistory'
+};
+/*
+ * Enums
+ */
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+    ReadUncommitted: 'ReadUncommitted',
+    ReadCommitted: 'ReadCommitted',
+    RepeatableRead: 'RepeatableRead',
+    Serializable: 'Serializable',
+    Snapshot: 'Snapshot'
+});
+export const AiMessageScalarFieldEnum = {
+    id: 'id',
+    sessionId: 'sessionId',
+    historyId: 'historyId',
+    type: 'type',
+    content: 'content',
+    thoughts: 'thoughts',
+    model: 'model',
+    tokens: 'tokens',
+    toolCalls: 'toolCalls',
+    agentId: 'agentId',
+    metadata: 'metadata',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
+    deletedAt: 'deletedAt'
+};
+export const AiChatHistoryScalarFieldEnum = {
+    id: 'id',
+    sessionId: 'sessionId',
+    title: 'title',
+    summary: 'summary',
+    messageCount: 'messageCount',
+    totalTokens: 'totalTokens',
+    firstMessageAt: 'firstMessageAt',
+    lastMessageAt: 'lastMessageAt',
+    metadata: 'metadata',
+    deletedAt: 'deletedAt'
+};
+export const SortOrder = {
+    asc: 'asc',
+    desc: 'desc'
+};
+export const NullsOrder = {
+    first: 'first',
+    last: 'last'
+};

package/lib/generated/sqlserver/models/AiChatHistory.js

@@ -0,0 +1 @@
+export {};

package/lib/generated/sqlserver/models/AiMessage.js

@@ -0,0 +1 @@
+export {};

package/lib/generated/sqlserver/models.js

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,224 @@
+/**
+ * dsh-storage — mirrors the dsh session event stream into the ai_messages /
+ * ai_chat_histories tables (MySQL/PostgreSQL/SQLite/SQL Server).
+ *
+ * Design: dsh's own session persistence (JSONL/SQLite) stays authoritative.
+ * This plugin taps `session/event` (the same seam the built-in persistence
+ * coordinator uses) and projects events into MessageRow / SessionRow shaped
+ * after the source project's ai_messages / ai_chat_histories tables.
+ *
+ * A2A task state (task metadata in Redis, workspace archives in GCS) is NOT
+ * here — that belongs to the A2A layer, see dsh-a2a's TaskStore backends.
+ *
+ * Resume caveat (docs/subsystems/persistence.md): constructor seeds do not
+ * emit events. On agent resume, only events >= `session.firstLiveSeq` fire
+ * on this stream — historical rows must come from the database itself, not
+ * from replaying the tap.
+ *
+ * @module dsh-storage
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { DatabaseBackend } from './backends/database.js';
+import { projectEvent, usageSampleOf } from './projector.js';
+export const name = 'dsh-storage';
+// Event-tap only: no hard service dependency. Add 'sessionPersistence' to
+// `inject` if you want fail-fast when persistence is not composed.
+export const inject = [];
+export const Config = Schema.object({
+    enabled: Schema.boolean().default(false),
+    database: Schema.object({
+        enabled: Schema.boolean().default(false),
+        provider: Schema.union(['mysql', 'postgresql', 'sqlite', 'sqlserver']).default('sqlite'),
+        url: Schema.string().role('secret').default(''),
+    }),
+});
+/** Metadata key for our usage bookkeeping — namespaced so other writers' fields never collide with it. */
+const LAST_USAGE_KEY = 'dsh-storage:lastUsage';
+/** Shape-guarded restore of our usage sample from arbitrary metadata. */
+function usageSampleOfMetadata(value) {
+    const v = value;
+    return v &&
+        typeof v.key === 'string' &&
+        typeof v.input === 'number' &&
+        typeof v.output === 'number'
+        ? { key: v.key, input: v.input, output: v.output }
+        : undefined;
+}
+export function apply(ctx, config) {
+    // Lifecycle: this cordis fork has no 'ready'/'dispose' events — startup
+    // work goes in ctx.effect() (runs immediately at plugin load; the returned
+    // disposer runs on fiber unload at shutdown). Event taps verified against
+    // @deepseek-ai/dsh-session@0.1.0-rc.7: session/event(session, event),
+    // session/disposed(session), and the awaited session/flush(session)
+    // durability checkpoint. The cast stays because the dsh-session types that
+    // declare these event names are not installed.
+    const on = ctx.on.bind(ctx);
+    if (!config.enabled || !config.database.enabled || !config.database.url)
+        return;
+    const backends = [
+        new DatabaseBackend({
+            provider: config.database.provider,
+            url: config.database.url,
+        }),
+    ];
+    const sessions = new Map();
+    // Row writes are fire-and-forget during the run, but tracked so the
+    // session/flush checkpoint and shutdown can drain them — a one-shot
+    // (headless) run would otherwise lose the tail events to process exit.
+    const pending = new Set();
+    function track(task) {
+        pending.add(task);
+        void task.finally(() => pending.delete(task));
+        return task;
+    }
+    function guard(call) {
+        // Mirroring must never break the agent loop: log and swallow.
+        return Promise.all(backends.map((backend) => call(backend).catch((error) => console.error(`[dsh-storage] ${backend.name} error:`, error)))).then(() => { });
+    }
+    // Backend init starts at plugin load; every write chains behind it so no
+    // row is lost to a still-connecting backend.
+    let started;
+    function fanout(call) {
+        return track(started.then(() => guard(call)));
+    }
+    // Per-session serialization: all event processing for one session runs
+    // through a promise chain, so rollup writes complete in event order
+    // (latest-wins — concurrent absolute snapshots must not land out of order)
+    // and the first event of an unknown session seeds its accumulator from the
+    // stored row before any write (resume: constructor seeds are not re-emitted,
+    // so history must come from the database, not from zero).
+    const chains = new Map();
+    function enqueue(sessionId, task) {
+        // First task of a session also chains behind backend init, so seedAccum
+        // never reads from a still-connecting backend (prisma === null would
+        // masquerade as "row not found" and zero-seed over the stored rollup).
+        const next = (chains.get(sessionId) ?? started)
+            .then(task)
+            .catch((error) => console.error('[dsh-storage] mirror task error:', error));
+        chains.set(sessionId, next);
+        track(next);
+    }
+    async function seedAccum(sessionId) {
+        // "Row not found" (a new session) is the only zero-seed case. A read
+        // failure is NOT "not found": fail the task so the next event re-seeds,
+        // instead of accumulating from zero and overwriting the stored rollup.
+        let readFailure;
+        for (const backend of backends) {
+            try {
+                const row = await backend.readSession?.(sessionId);
+                if (row) {
+                    return {
+                        messageCount: row.messageCount,
+                        totalTokens: row.totalTokens,
+                        title: row.title ?? undefined,
+                        firstMessageAt: row.firstMessageAt ?? undefined,
+                        lastMessageAt: row.lastMessageAt ?? undefined,
+                        // Preserve every existing metadata field; we only own our key.
+                        metadata: { ...(row.metadata ?? {}) },
+                        usageSample: usageSampleOfMetadata(row.metadata?.[LAST_USAGE_KEY]),
+                    };
+                }
+            }
+            catch (error) {
+                readFailure ??= error;
+                console.error(`[dsh-storage] ${backend.name} error:`, error);
+            }
+        }
+        if (readFailure)
+            throw readFailure;
+        return { messageCount: 0, totalTokens: 0, metadata: {} };
+    }
+    ctx.effect(() => {
+        started = track(guard(async (backend) => backend.init?.()));
+        return async () => {
+            sessions.clear();
+            await Promise.all([...pending]);
+            await guard(async (backend) => backend.close?.());
+        };
+    });
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    on('session/event', (session, event) => {
+        const sessionId = session?.id ?? 'unknown';
+        enqueue(sessionId, async () => {
+            let accum = sessions.get(sessionId);
+            if (!accum) {
+                accum = await seedAccum(sessionId);
+                sessions.set(sessionId, accum);
+            }
+            const row = projectEvent(session, event, sessionId);
+            if (row) {
+                accum.messageCount += 1;
+                accum.firstMessageAt ??= row.createdAt;
+                accum.lastMessageAt = row.createdAt;
+                await fanout((backend) => backend.upsertMessage(row));
+            }
+            // Replacement usage accounting: the latest sample for a (turn, step)
+            // supersedes the previous one — fold only the delta, so the
+            // chunk↔message pair and progressive samples never double-count, and a
+            // failed step (usage chunk, no message) still counts. Samples of one
+            // step arrive adjacently, so a single latest sample is all we track.
+            const sampled = usageSampleOf(event);
+            let usageDelta = 0;
+            if (sampled) {
+                const prev = accum.usageSample;
+                usageDelta =
+                    sampled.sample.input +
+                        sampled.sample.output -
+                        (prev && prev.key === sampled.key ? prev.input + prev.output : 0);
+                if (!prev || prev.key !== sampled.key || usageDelta !== 0) {
+                    accum.usageSample = { key: sampled.key, ...sampled.sample };
+                    accum.totalTokens += usageDelta;
+                }
+            }
+            // Latest-wins title snapshot (log-only `session/title` event; payload
+            // { title, messageSeqs, source } verified against dsh-session-title@0.1.0-rc.7).
+            if (event?.type === 'session/title' && typeof event.data?.title === 'string') {
+                accum.title = event.data.title;
+            }
+            if (row ||
+                usageDelta !== 0 ||
+                event?.type === 'turn/end' ||
+                event?.type === 'session/title') {
+                // Merge our bookkeeping into the existing metadata instead of
+                // replacing the column — other fields (present or future) survive.
+                const metadata = {
+                    ...accum.metadata,
+                    ...(accum.usageSample ? { [LAST_USAGE_KEY]: accum.usageSample } : {}),
+                };
+                const sessionRow = {
+                    sessionId,
+                    title: accum.title ?? null,
+                    messageCount: accum.messageCount,
+                    totalTokens: accum.totalTokens,
+                    firstMessageAt: accum.firstMessageAt ?? null,
+                    lastMessageAt: accum.lastMessageAt ?? null,
+                    ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+                };
+                await fanout((backend) => backend.upsertSession(sessionRow));
+            }
+        });
+    });
+    on('session/disposed', (session) => {
+        const sessionId = session?.id ?? 'unknown';
+        // The delete must run inside the session's chain — a synchronous delete
+        // here races the queued event tasks (the map may not even have the entry
+        // yet at emit time, and queued tasks would keep growing the accumulator
+        // the dispose was meant to drop).
+        enqueue(sessionId, async () => {
+            sessions.delete(sessionId);
+        });
+        // Delete the chain entry only once it has settled AND is still the same
+        // entry — deleting earlier would let a recreated session race the
+        // orphaned writes; skipping the delete when a new task has since chained
+        // on preserves order.
+        const chain = chains.get(sessionId);
+        chain?.finally(() => {
+            if (chains.get(sessionId) === chain)
+                chains.delete(sessionId);
+        });
+    });
+    // Durability checkpoint: the store awaits every session/flush listener.
+    on('session/flush', async () => {
+        await Promise.all([...pending]);
+    });
+}

package/lib/projector.js

@@ -0,0 +1,153 @@
+/**
+ * Projects dsh session events onto MessageRow / SessionRow.
+ *
+ * Event shapes verified against the dsh persistence catalog
+ * (https://deepseek-harness.github.io/deepseek-harness/reference/persistence-catalog)
+ * and the @deepseek-ai/dsh-llm message types:
+ * - envelope: `{ type, seq, time, data }` — payload lives under `data`.
+ * - surface events (the only ones producing LLM messages, and the only ones
+ *   projected to rows): `user/message`, `assistant/message`, `tool/result`.
+ * - token usage: `assistant/chunk` `{ type: 'usage' }` is authoritative per
+ *   step; `assistant/message`'s `data.usage` only counts when no usage chunk
+ *   was seen for the step (dedup in usageOf). `turn/end` carries none — it
+ *   only serves as a rollup checkpoint.
+ * - compaction summaries enter the surface as a `user/message` with
+ *   `surfaceOp: replace`, so they flow through the user path unchanged.
+ */
+import { randomUUID } from 'node:crypto';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Visible text of a message: its `text` blocks, unwrapping tool-result blocks. */
+function textOf(message) {
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    return blocks
+        .map((b) => {
+        if (b?.type === 'text')
+            return b.text ?? '';
+        if (b?.type === 'tool-result' && Array.isArray(b.content))
+            return textOf({ content: b.content });
+        return '';
+    })
+        .join('');
+}
+/** Reasoning text of an assistant message, if it carried reasoning blocks. */
+function reasoningOf(message) {
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    const text = blocks
+        .filter((b) => b?.type === 'reasoning')
+        .map((b) => b.text)
+        .join('');
+    return text || undefined;
+}
+function toolPartsOf(message) {
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    const calls = blocks.filter((b) => b?.type === 'tool-call');
+    return calls.length > 0 ? calls : undefined;
+}
+/**
+ * Map one session event to zero or one message row. Returns null for events
+ * that should not be persisted as standalone rows (log-only events: chunks,
+ * turn/step lifecycle, approvals, ...).
+ */
+export function projectEvent(_session, event, sessionId) {
+    const data = event?.data ?? {};
+    const base = {
+        sessionId,
+        historyId: null,
+        agentId: 'main',
+        createdAt: new Date(event?.time ?? Date.now()),
+    };
+    switch (event?.type) {
+        case 'user/message': {
+            // data IS the UserMessage.
+            const message = data;
+            return {
+                ...base,
+                id: message.id ?? randomUUID(),
+                type: 'user',
+                content: textOf(message),
+                metadata: { event: event.type, seq: event.seq },
+            };
+        }
+        case 'assistant/message': {
+            const message = data.message;
+            return {
+                ...base,
+                id: message?.id ?? randomUUID(),
+                type: 'model',
+                content: textOf(message),
+                thoughts: reasoningOf(message),
+                model: message?.source?.model ?? undefined,
+                tokens: data.usage ?? undefined,
+                toolCalls: toolPartsOf(message),
+                metadata: {
+                    event: event.type,
+                    seq: event.seq,
+                    ...(data.interrupted ? { interrupted: true } : {}),
+                },
+            };
+        }
+        case 'tool/result': {
+            const message = data.message;
+            const callId = message?.source?.callId ?? undefined;
+            return {
+                ...base,
+                id: message?.id ?? randomUUID(),
+                type: 'tool',
+                content: textOf(message),
+                toolCalls: [
+                    {
+                        callId,
+                        result: message?.content?.[0] ?? null,
+                        // Internal failure identity, when the call failed.
+                        ...(data.error ? { error: { name: data.error.name, code: data.error.code } } : {}),
+                    },
+                ],
+                metadata: { event: event.type, seq: event.seq, callId },
+            };
+        }
+        default:
+            // Log-only events (assistant/chunk, turn/step lifecycle, approvals,
+            // compaction markers, ...) are not standalone rows; usage rolls up into
+            // SessionRow via usageOf (usage chunks and assistant/message).
+            return null;
+    }
+}
+/**
+ * Extract the usage sample carried by one event, keyed by its step, or null
+ * when the event carries none.
+ *
+ * dsh-llm emits usage as:
+ * - `assistant/chunk` with `chunk.type === 'usage'` — the step's accounting,
+ *   emitted even when the request later fails (a failed step produces no
+ *   assistant/message, so message-only accounting would miss it entirely);
+ * - `assistant/message.data.usage` — the same step's final accounting.
+ *
+ * Samples for one `(turn, step)` are REPLACEMENTS, not additive: later
+ * samples supersede earlier ones (progressive chunks, then the message).
+ * The caller keeps the latest sample per step and folds only the delta into
+ * its rollup. Totals include the cache buckets: cacheRead/cacheWrite are
+ * billed in their own buckets (observed cacheReadTokens ≫ inputTokens in
+ * dsh session logs — they are not subsets of inputTokens).
+ */
+export function usageSampleOf(event) {
+    const total = (u) => ({
+        input: (u?.inputTokens ?? 0) + (u?.cacheReadTokens ?? 0) + (u?.cacheWriteTokens ?? 0),
+        output: u?.outputTokens ?? 0,
+    });
+    let data;
+    let usage;
+    if (event?.type === 'assistant/chunk' && event.data?.chunk?.type === 'usage') {
+        data = event.data;
+        usage = data.chunk.usage;
+    }
+    else if (event?.type === 'assistant/message') {
+        data = event.data;
+        usage = data?.usage;
+    }
+    else {
+        return null;
+    }
+    if (!usage || data?.turn == null || data?.step == null)
+        return null;
+    return { key: `${data.turn}:${data.step}`, sample: total(usage) };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * MySQL/PostgreSQL/SQLite/SQL Server backend via Prisma 7. The clients are
+ * pre-generated at package build time (`pnpm generate`, see
+ * scripts/prisma-generate.mjs) from the schema variants in prisma/ and
+ * shipped compiled in lib/generated — consumers never run `prisma generate`.
+ *
+ * Prisma 7 requires a driver adapter per database; `@prisma/client` and the
+ * adapter for your provider are optional peer dependencies (sqlite uses
+ * `@prisma/adapter-libsql` — no native build scripts, unlike
+ * `@prisma/adapter-better-sqlite3`). Table creation
+ * (`prisma db push` / migrations) uses the shipped schema variant with the
+ * connection URL in the user's prisma.config.ts.
+ */
+import type { MessageRow, SessionRow, StorageBackend } from '../types.js';
+export type DatabaseProvider = 'mysql' | 'postgresql' | 'sqlite' | 'sqlserver';
+export interface DatabaseBackendConfig {
+    provider: DatabaseProvider;
+    /** Full connection URL, e.g. mysql://user:pass@host:3306/dbname, file:/data/dsh.db */
+    url: string;
+}
+export declare function createAdapter(config: DatabaseBackendConfig): Promise<unknown>;
+export declare class DatabaseBackend implements StorageBackend {
+    private config;
+    readonly name = "database";
+    private prisma;
+    constructor(config: DatabaseBackendConfig);
+    /** Load the pre-generated client for the configured provider (seam for tests). */
+    protected loadClient(): Promise<any>;
+    init(): Promise<void>;
+    /** JSON column value, text-serialized on SQL Server (no Prisma Json type). */
+    private jsonField;
+    private toDbData;
+    upsertMessage(row: MessageRow): Promise<void>;
+    readSession(sessionId: string): Promise<SessionRow | null>;
+    upsertSession(row: SessionRow): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/types/generated/mysql/browser.d.ts

@@ -0,0 +1,15 @@
+import * as Prisma from './internal/prismaNamespaceBrowser.js';
+export { Prisma };
+export * as $Enums from './enums.js';
+export * from './enums.js';
+/**
+ * Model AiMessage
+ * One row per projected session event (user message, assistant message,
+ * tool call/result, compression snapshot, ...).
+ */
+export type AiMessage = Prisma.AiMessageModel;
+/**
+ * Model AiChatHistory
+ * Per-session rollup, maintained incrementally by the projector.
+ */
+export type AiChatHistory = Prisma.AiChatHistoryModel;

package/lib/types/generated/mysql/client.d.ts

@@ -0,0 +1,34 @@
+import * as runtime from "@prisma/client/runtime/client";
+import * as $Class from "./internal/class.js";
+import * as Prisma from "./internal/prismaNamespace.js";
+export * as $Enums from './enums.js';
+export * from "./enums.js";
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more AiMessages
+ * const aiMessages = await prisma.aiMessage.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export declare const PrismaClient: $Class.PrismaClientConstructor;
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+export { Prisma };
+/**
+ * Model AiMessage
+ * One row per projected session event (user message, assistant message,
+ * tool call/result, compression snapshot, ...).
+ */
+export type AiMessage = Prisma.AiMessageModel;
+/**
+ * Model AiChatHistory
+ * Per-session rollup, maintained incrementally by the projector.
+ */
+export type AiChatHistory = Prisma.AiChatHistoryModel;