@wfm-cn/dsh-storage 0.0.0-stage → 0.3.0

package/lib/status-route.js

@@ -0,0 +1,172 @@
+/**
+ * Host→browser bridge for the settings panel: exposes the dshStorageStatus
+ * service over the DSH connection generic-RPC channel `/dsh-storage`.
+ *
+ * Pattern verified against the installed reference plugins (ds-harness-remote
+ * `registerControlRoute`, dsh-video-skin settings.section client): the browser
+ * client calls `ctx.connection.rpc.call('/dsh-storage', endpoint, payload)`,
+ * which POSTs `{type:'client-request', rpcId, method, payload}` to
+ * `/<channel>/<endpoint>` and expects `{type:'server-response', rpcId,
+ * result:{ok:true,value}|{ok:false,error:{code,message,details}}}`. When the
+ * webServer service is available we serve that path with a prefix route
+ * (guarded by `connection.requestRejection` for authentication); otherwise we
+ * fall back to `connection.rpc.handle` for in-process carriers. Both halves
+ * stay optional (`ctx.get`), so profiles without a web carrier simply skip
+ * the bridge.
+ */
+import { syncConfigProblem } from './config.js';
+export const STATUS_CHANNEL = '/dsh-storage';
+const ENDPOINT_SEGMENT = /^[A-Za-z0-9_$.-]+$/;
+function badRequest(message) {
+    return { ok: false, error: { code: 'gateway/bad-request', message, details: {} } };
+}
+/**
+ * Guard for cfg-taking endpoints. Rejections name the offending field (via
+ * syncConfigProblem) so a cleared/NaN port surfaces as 'cfg.port must be…',
+ * not a misleading generic 'requires a cfg object'.
+ */
+function cfgGuard(endpoint, cfg) {
+    const problem = syncConfigProblem(cfg);
+    return problem === undefined
+        ? { cfg: cfg }
+        : { error: { code: 'gateway/bad-request', message: `${endpoint}: ${problem}`, details: {} } };
+}
+/** Dispatch one endpoint; never throws — failures become ok:false results. */
+async function dispatch(service, endpoint, payload) {
+    const body = (typeof payload === 'object' && payload !== null ? payload : {});
+    try {
+        switch (endpoint) {
+            case 'snapshot':
+                return { ok: true, value: service.snapshot() };
+            case 'testConnection': {
+                const guarded = cfgGuard('testConnection', body.cfg);
+                if ('error' in guarded)
+                    return { ok: false, error: guarded.error };
+                return { ok: true, value: await service.testConnection(guarded.cfg) };
+            }
+            case 'createTables': {
+                const guarded = cfgGuard('createTables', body.cfg);
+                if ('error' in guarded)
+                    return { ok: false, error: guarded.error };
+                return { ok: true, value: await service.createTables(guarded.cfg) };
+            }
+            case 'getConfig':
+                return { ok: true, value: service.getConfig() };
+            case 'saveConfig': {
+                const guarded = cfgGuard('saveConfig', body.cfg);
+                if ('error' in guarded)
+                    return { ok: false, error: guarded.error };
+                return { ok: true, value: service.saveConfig(guarded.cfg) };
+            }
+            case 'backfill':
+                return { ok: true, value: await service.backfill() };
+            case 'toasts':
+                if (body.sinceId !== undefined && typeof body.sinceId !== 'number')
+                    return badRequest('toasts sinceId must be a number');
+                return { ok: true, value: service.toasts({ sinceId: body.sinceId }) };
+            default:
+                return badRequest(`unknown endpoint ${JSON.stringify(endpoint)}`);
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: 'gateway/internal',
+                message: error instanceof Error ? error.message : String(error),
+                details: {},
+            },
+        };
+    }
+}
+function endpointFromPath(pathname) {
+    if (!pathname.startsWith(`${STATUS_CHANNEL}/`))
+        return undefined;
+    const endpoint = pathname.slice(STATUS_CHANNEL.length + 1);
+    if (!ENDPOINT_SEGMENT.test(endpoint))
+        return undefined;
+    return endpoint;
+}
+function parseClientRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const v = value;
+    if (v.type !== 'client-request' || typeof v.rpcId !== 'string' || typeof v.method !== 'string')
+        return undefined;
+    return { type: 'client-request', rpcId: v.rpcId, method: v.method, payload: v.payload };
+}
+function writeJson(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+function fullResponse(rpcId, result) {
+    return { type: 'server-response', rpcId, result };
+}
+/**
+ * Register the /dsh-storage channel. Wire order mirrors ds-harness-remote's
+ * control route: an authenticated webServer prefix route when both services
+ * allow it, otherwise connection.rpc.handle for logical carriers.
+ */
+export function registerStatusRoute(ctx, service) {
+    const connection = ctx.get('connection');
+    if (!connection)
+        return undefined;
+    const handler = (endpoint, payload) => dispatch(service, endpoint, payload);
+    const webServer = ctx.get('webServer');
+    if (webServer !== undefined && connection.requestRejection !== undefined) {
+        const dispose = webServer.register({
+            kind: 'prefix',
+            path: STATUS_CHANNEL,
+            handler: async (req, res) => {
+                const rejection = connection.requestRejection?.(req);
+                if (rejection !== undefined) {
+                    res.writeHead(rejection);
+                    res.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+                    return;
+                }
+                const endpoint = endpointFromPath(new URL(req.url ?? '/', 'http://dsh.internal').pathname);
+                if (req.method !== 'POST' || endpoint === undefined) {
+                    writeJson(res, 404, 'not found');
+                    return;
+                }
+                const contentType = Array.isArray(req.headers?.['content-type'])
+                    ? req.headers['content-type'][0]
+                    : req.headers?.['content-type'];
+                if ((contentType ?? '').split(';', 1)[0]?.trim().toLowerCase() !== 'application/json') {
+                    writeJson(res, 415, 'content type must be application/json');
+                    return;
+                }
+                let body;
+                try {
+                    const chunks = [];
+                    for await (const chunk of req) {
+                        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                    }
+                    body = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+                }
+                catch {
+                    writeJson(res, 400, 'body is not JSON');
+                    return;
+                }
+                const message = parseClientRequest(body);
+                if (message === undefined || message.method !== endpoint) {
+                    writeJson(res, 200, fullResponse('invalid-request', badRequest('invalid client-request message')));
+                    return;
+                }
+                try {
+                    writeJson(res, 200, fullResponse(message.rpcId, await handler(endpoint, message.payload)));
+                }
+                catch (error) {
+                    res.writeHead(500);
+                    res.end(`handler failure: ${String(error)}`);
+                }
+            },
+        });
+        return () => void dispose();
+    }
+    const rpcHandle = connection.rpc?.handle;
+    if (rpcHandle === undefined)
+        return undefined;
+    const dispose = rpcHandle(STATUS_CHANNEL, handler, { authority: 'loopback' });
+    return () => void dispose();
+}

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

@@ -0,0 +1,78 @@
+/**
+ * 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;
+    /**
+     * IANA-named offset for the mariadb driver's `timezone` option (e.g.
+     * '+08:00'), applied when writing DATETIME columns. Only used by mysql.
+     */
+    timezone?: string;
+    /**
+     * Device identifier stamped on every ai_messages / ai_chat_histories row
+     * this backend writes, so several machines can share one database.
+     * Falls back to the OS hostname when unset.
+     */
+    device?: string;
+}
+/**
+ * Parse mysql://user:password@host[:port]/database into discrete connection
+ * options for the mariadb driver adapter. Passing the URI string itself
+ * pool-times-out in production (verified against a real MySQL 8.4);
+ * discrete host/port/user/password/database options work. Components are
+ * percent-decoded — credentials with @ : / arrive encoded in the URL.
+ */
+export declare function parseMysqlUrl(url: string): {
+    host: string;
+    port?: number;
+    user: string;
+    password: string;
+    database: 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);
+    /** Device identifier stamped on rows written through this backend. */
+    private get device();
+    private client;
+    /** 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;
+    private writeMessage;
+    upsertMessage(row: MessageRow): Promise<void>;
+    readMessages(sessionId: string, messageId: string): Promise<MessageRow[]>;
+    readToolCallMessages(sessionId: string, callId: string): Promise<MessageRow[]>;
+    private readRows;
+    readSession(sessionId: string): Promise<SessionRow | null>;
+    /**
+     * Max created_at per session over active message rows — the database-side
+     * watermark for backfill gap detection (sessions with newer local logs
+     * have missing events).
+     */
+    latestPerSession(): Promise<Map<string, Date>>;
+    private writeSession;
+    upsertSession(row: SessionRow): Promise<void>;
+    upsertEvent(message: MessageRow | null, session: SessionRow): Promise<void>;
+    archiveSession(sessionId: string): Promise<string | null>;
+    close(): Promise<void>;
+}

package/lib/types/backfill.d.ts

@@ -0,0 +1,67 @@
+import type { StorageBackend } from './types.js';
+/** Exactly the event types the live tap mirrors (see index.ts session/event). */
+export declare const MIRROR_EVENT_TYPES: readonly ["user/message", "assistant/message", "assistant/attempt", "tool/result", "turn/end", "session/title", "compaction/end"];
+interface MirrorEvent {
+    type: string;
+    seq?: number;
+    time?: number;
+    data?: Record<string, unknown>;
+}
+/** Metadata key for the usage high-water mark — shared with the live tap. */
+export declare const LAST_USAGE_KEY = "dsh-storage:lastUsage";
+/** One session with missing events: replay starts at `fromSeq` (inclusive). */
+export interface BackfillGap {
+    sessionId: string;
+    fromSeq: number;
+}
+export interface BackfillSummary {
+    /** Sessions whose events were replayed (excludes reported errors). */
+    sessions: number;
+    /** Message rows written by this run. */
+    replayed: number;
+    /** Events already present in the database (idempotent skips). */
+    skipped: number;
+    /** Per-session failures — one entry per session that could not be replayed. */
+    errors: string[];
+}
+interface LogFile {
+    file: string;
+    mtime: Date;
+}
+interface SessionLog extends LogFile {
+    sessionId: string;
+}
+/**
+ * Read one session log as text. Plain files are read directly; `.zstd` files
+ * are decompressed through the first available system binary.
+ */
+export declare function readSessionLogText(file: string, binaries?: readonly string[]): Promise<string>;
+/** Parse JSONL lines into event objects; malformed lines are skipped. */
+export declare function parseSessionEvents(text: string): MirrorEvent[];
+/**
+ * Enumerate session logs. Real DSH layout is
+ * `<sessionsDir>/<workspace-dir>/<session-id>/session.v4.jsonl[.zstd]`
+ * (two levels); a log directly under a child directory is also accepted so
+ * a flattened sessions dir keeps working.
+ */
+export declare function listSessionLogs(sessionsDir: string): Promise<SessionLog[]>;
+/**
+ * Select sessions whose latest local activity (log mtime) is newer than the
+ * database's last mirrored activity. Sessions absent from the database are
+ * selected for a full replay (fromSeq 0) — but only when their log holds at
+ * least one row-producing event; a log-only session mirrors no rows and its
+ * "gap" would never converge. For known sessions `fromSeq` is the sequence
+ * of the first row-producing event newer than the DB watermark.
+ */
+export declare function computeGap(sessionsDir: string, dbLatestPerSession: Map<string, Date>): Promise<BackfillGap[]>;
+/** computeGap + replayEvents in one call, for the panel button. */
+export declare function backfillAll(sessionsDir: string, backend: StorageBackend & {
+    latestPerSession?(): Promise<Map<string, Date>>;
+}): Promise<BackfillSummary>;
+/**
+ * Replay the missing events of each gap through the projector into the
+ * backend. Idempotent: message rows whose deterministic id already exists
+ * are skipped without error, and the session rollup is never double-counted.
+ */
+export declare function replayEvents(gaps: BackfillGap[], sessionsDir: string, backend: StorageBackend): Promise<BackfillSummary>;
+export {};

package/lib/types/client/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser half of dsh-storage: registers the settings panel into the DSH
+ * settings page (`settings.section` slot) and reaches the host plugin's
+ * dshStorageStatus service through the connection generic-RPC channel
+ * /dsh-storage (registered host-side in src/status-route.ts).
+ *
+ * Module shape follows the reference client plugins (dsh-pet, dsh-video-skin,
+ * ds-harness-remote): a `window.__ModuleLoader__.load({ id, factory })` call
+ * whose factory receives the page's `require` — React comes from the host
+ * page, never bundled. Built by esbuild into the single-file lib/client.js.
+ */
+export {};

package/lib/types/client/panel.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Settings-panel component for dsh-storage (会话存储镜像).
+ *
+ * Authored against the reference client plugins (dsh-pet / dsh-video-skin):
+ * the browser half receives React from the host module loader inside the
+ * __ModuleLoader__ factory, so the component is built through a factory that
+ * takes the React module — no module-scope React import survives into the
+ * bundle. All RPC goes through the injected `client` (connection rpc; see
+ * src/client/index.ts), which keeps this file render-pure and testable with
+ * a fake client.
+ */
+import type { SyncConfig } from '../config.js';
+import type { BackfillSummary } from '../backfill.js';
+/** Shapes mirrored from the host (type-only imports — erased in the bundle). */
+export interface HealthStatus {
+    state: 'ok' | 'down' | 'disabled' | 'config-error';
+    lastOkAt?: number;
+    lastError?: string;
+    retryCount: number;
+    mirroredTotal?: number;
+}
+export type TestResult = 'ok' | 'no-tables' | `fail:${string}`;
+/** Promise-based panel API; the client entry implements it over connection rpc. */
+export interface StorageClient {
+    snapshot(): Promise<HealthStatus>;
+    testConnection(cfg: SyncConfig): Promise<TestResult>;
+    createTables(cfg: SyncConfig): Promise<'ok' | `fail:${string}`>;
+    getConfig(): Promise<{
+        config: SyncConfig;
+        error?: 'parse' | 'missing-field';
+    }>;
+    saveConfig(cfg: SyncConfig): Promise<unknown>;
+    backfill(): Promise<BackfillSummary>;
+}
+export declare const DEFAULT_TIMEZONES: string[];
+/** Mirrors config.ts isValidPort — kept local so no node builtins enter the browser bundle. */
+export declare function isValidPort(value: unknown): value is number;
+/**
+ * The cfg object to persist: the port is sent only when it is a valid
+ * integer — a cleared/garbage port field is omitted so the RPC rejects it
+ * with an honest per-field error instead of building a host:NaN URL.
+ */
+export declare function buildSaveConfig(cfg: SyncConfig): SyncConfig;
+/** Structural React surface the factory needs (satisfied by react 18). */
+export interface ReactLike {
+    createElement: any;
+    useState: <S>(initial: S) => [S, (value: S | ((prev: S) => S)) => void];
+    useEffect: (effect: () => void | (() => void), deps?: unknown[]) => void;
+}
+export type Tone = 'ok' | 'warn' | 'bad' | 'idle';
+/** Status-light copy per HealthStatus.state. */
+export declare function statusView(status: HealthStatus): {
+    tone: Tone;
+    label: string;
+    details: string[];
+};
+/** Three-state connection-test copy: green ok / yellow no-tables / red fail. */
+export declare function testResultView(result: TestResult): {
+    tone: Tone;
+    label: string;
+};
+export declare function createResultView(result: 'ok' | `fail:${string}`): {
+    tone: Tone;
+    label: string;
+};
+/** 补传 summary copy: green when clean, yellow when some sessions failed. */
+export declare function backfillResultView(summary: BackfillSummary): {
+    tone: Tone;
+    label: string;
+};
+export interface PanelProps {
+    client: StorageClient;
+    /** Status poll interval; default 30s per the task brief. */
+    pollMs?: number;
+}
+export declare function makeStoragePanel(React: ReactLike): {
+    (props: PanelProps): any;
+    displayName: string;
+};

package/lib/types/client/toast.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Sync-status toast notifications (Task 6): a standalone React portal the
+ * client entry mounts on document.body — independent of the settings panel
+ * section, so toasts appear even when the panel is closed. The host records
+ * toasts on HealthMonitor transitions (src/notify.ts); this component polls
+ * them through the status bridge with a `sinceId` cursor.
+ *
+ * Factory pattern like panel.tsx: React (and react-dom's createPortal) come
+ * from the host page's module loader, never bundled.
+ */
+import type { StorageToast } from '../notify.js';
+export interface ToastClient {
+    toasts(payload: {
+        sinceId: number;
+    }): Promise<StorageToast[]>;
+}
+/** Default poll interval; transitions are rare, this only carries toasts. */
+export declare const TOAST_POLL_MS = 5000;
+/** How long a toast stays on screen. */
+export declare const TOAST_DISPLAY_MS = 8000;
+export interface ReactLike {
+    createElement: any;
+    useState: <S>(initial: S) => [S, (value: S | ((prev: S) => S)) => void];
+    useEffect: (effect: () => void | (() => void), deps?: unknown[]) => void;
+    useRef: <T>(initial: T) => {
+        current: T;
+    };
+}
+export interface PortalDom {
+    createPortal: (node: any, container: Element) => any;
+}
+export declare function makeToastHost(React: ReactLike, ReactDOM: PortalDom): {
+    (props: {
+        client: ToastClient;
+        pollMs?: number;
+    }): any;
+    displayName: string;
+};

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/lib/types/config.d.ts

@@ -0,0 +1,52 @@
+export type SyncConfig = {
+    enabled: boolean;
+    provider: 'mysql' | 'postgresql' | 'sqlite' | 'sqlserver';
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    timezone: string;
+    /** Identifier stamped on mirrored rows so several machines can share one database. */
+    device: string;
+};
+/**
+ * Default device identifier: the OS hostname, truncated to the column width
+ * (VARCHAR(100)). Empty hostnames (theoretically possible) fall back to a
+ * stable placeholder so rows are never stamped with ''.
+ */
+export declare function defaultDevice(): string;
+export declare const DEFAULT_CONFIG: SyncConfig;
+/** Resolve the DSH home directory: $DSH_HOME or ~/.dsh. */
+export declare function dshHome(): string;
+export declare function defaultConfigPath(): string;
+/**
+ * Parse a config timezone string ('+08:00', '-05:00', '+05:30', 'Z'/'UTC')
+ * into signed minutes east of UTC. Invalid or absent input → 0 (the caller
+ * decides whether to warn). This mirrors what the patched
+ * @prisma/adapter-mariadb reads via globalThis.__DSH_STORAGE_TZ_OFFSET_MIN__.
+ */
+export declare function tzOffsetMinutes(tz: string): number;
+/** Valid TCP port for the form: a finite integer in [0, 65535] (0 allowed for sqlite configs). */
+export declare function isValidPort(value: unknown): value is number;
+/**
+ * First shape problem with a candidate sync config, or undefined when valid.
+ * Field-specific reasons keep RPC rejections honest ('cfg.port must be…'
+ * instead of a generic 'requires a cfg object').
+ */
+export declare function syncConfigProblem(value: unknown): string | undefined;
+export declare function loadConfig(path?: string): {
+    config: SyncConfig;
+    error?: 'parse' | 'missing-field';
+};
+/**
+ * Atomic write: temp file in the same directory + rename. The file holds the
+ * database password, so it is created owner-only (0600) — writeFileSync's
+ * mode is masked by umask, so chmod the temp file explicitly before rename
+ * (rename keeps the temp file's mode, so rewrites stay 0600 too).
+ */
+export declare function saveConfig(c: SyncConfig, path?: string): void;
+/** Watch the config file; bursts are debounced (300ms). Returns a disposer. */
+export declare function watchConfig(path: string, cb: (c: SyncConfig) => void): () => void;
+/** Build a connection URL from discrete form fields; sqlite → file:<path>. */
+export declare function configToUrl(c: SyncConfig): string;

package/lib/types/ddl.d.ts

@@ -0,0 +1,49 @@
+import { type SyncConfig } from './config.js';
+export type CreateTableResult = 'ok' | `fail:${string}`;
+/**
+ * MySQL DDL — captured from Prisma 7.9 `db push` of
+ * prisma/schema.mysql.prisma (MySQL 8.4) via SHOW CREATE TABLE. Column
+ * types must match the schema exactly: char(36) ids, varchar lengths,
+ * longtext content, json columns, timestamp(0) message timestamps,
+ * datetime(6) history timestamps. ai_chat_histories is created first —
+ * ai_messages carries a foreign key into it.
+ */
+export declare const MYSQL_DDL: string[];
+/**
+ * SQLite DDL — captured from Prisma 7.9 `db push` of
+ * prisma/schema.sqlite.prisma (sqlite_master dump), converted to
+ * IF NOT EXISTS forms. The histories table precedes the FK-carrying
+ * messages table.
+ */
+export declare const SQLITE_DDL: string[];
+/** Embedded DDL statements for a provider; undefined → prisma-CLI fallback. */
+export declare function ddlStatementsFor(provider: SyncConfig['provider']): readonly string[] | undefined;
+/**
+ * Ensure both tables carry the nullable `device` column, then stamp every
+ * still-NULL row with `device` (the current machine's identifier — at
+ * migration time this machine owns all pre-feature rows). Executed by the
+ * panel's 「建表」 (createTables) and once per mirror startup; a no-op when
+ * the columns already exist (cheap information_schema check). mysql only —
+ * the other providers gain the column via their prisma schema `db push`.
+ *
+ * Returns 'ok' or a `fail:<reason>` string; never throws.
+ */
+export declare function ensureDeviceColumn(cfg: {
+    provider: SyncConfig['provider'];
+    url: string;
+    timezone?: string;
+}, device?: string): Promise<CreateTableResult>;
+/**
+ * Sanitize a device identifier for direct embedding into the migration SQL
+ * (no bound parameters — see ensureDeviceColumn). Strips quote, backslash,
+ * backtick and NUL characters and truncates to the column width; the value
+ * is still wrapped in single quotes at the call site.
+ */
+export declare function sqlString(device: string): string;
+/**
+ * Create the ai_messages / ai_chat_histories tables for `cfg.provider`.
+ * mysql/sqlite run embedded idempotent DDL over the adapter connection;
+ * postgresql/sqlserver shell out to `prisma db push` against the packaged
+ * schema variant (requires the prisma CLI — a devDependency).
+ */
+export declare function createTables(cfg: SyncConfig): Promise<CreateTableResult>;

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

@@ -0,0 +1,14 @@
+import * as Prisma from './internal/prismaNamespaceBrowser.js';
+export { Prisma };
+export * as $Enums from './enums.js';
+export * from './enums.js';
+/**
+ * Model AiMessage
+ * User and assistant messages; tool results update the assistant row's tool_calls.
+ */
+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,33 @@
+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
+ * User and assistant messages; tool results update the assistant row's tool_calls.
+ */
+export type AiMessage = Prisma.AiMessageModel;
+/**
+ * Model AiChatHistory
+ * Per-session rollup, maintained incrementally by the projector.
+ */
+export type AiChatHistory = Prisma.AiChatHistoryModel;