@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/{parts-BqIHMdyu.d.ts → chat-store/parts.d.ts}

@@ -1,9 +1,3 @@
-import { Part } from '@tangle-network/agent-interface';
-import { C as ChatInteractionField, a as ChatInteractionStatus, I as InteractionAnswers, N as NoticeKind } from './contract-OxG_jVMx.js';
-import { W as WorkProductPersistedPart } from './types-CCeYywdS.js';
-import { ChatPlanPersistedPart } from './plans/index.js';
-import { C as ChatMentionKind, a as ChatAttachmentKind, b as ChatAttachmentInput, F as FileMention } from './wire-DOZ-O6hD.js';
-
 /**
  * The stored shape of `message.parts` — one typed vocabulary for every part a
  * product persists into a chat transcript. NOT an ad-hoc union reverse-
@@ -58,21 +52,26 @@ import { C as ChatMentionKind, a as ChatAttachmentKind, b as ChatAttachmentInput
  *   `/stream`'s `normalizeToolEvent`) and then persisted identically — the
  *   store never sees a router-specific shape.
  */
-
+import type { Part as HarnessWirePart } from '@tangle-network/agent-interface';
+import type { ChatInteractionField, ChatInteractionStatus, InteractionAnswers, NoticeKind } from '../web-react/chat-interactions';
+import { type WorkProductPersistedPart } from '../work-product/types';
+import { type ChatPlanPersistedPart } from '../plans/index';
+import { type ChatAttachmentInput, type ChatAttachmentKind, type ChatMentionKind, type FileMention } from '../chat-routes/wire';
+export type { ChatMentionKind, ChatAttachmentKind };
 /** Start/end wall-clock millis, as normalized by `/stream`'s `normalizeTime`. */
-interface ChatPartTime {
+export interface ChatPartTime {
     start?: number;
     end?: number;
 }
 /** `id` is the harness's per-segment identity; absent on legacy/router parts,
  *  which collapse to a single logical text stream. Never invented client-side. */
-interface ChatTextPart {
+export interface ChatTextPart {
     type: 'text';
     text: string;
     id?: string;
 }
 /** Define a reasoning part of a chat with text content and optional metadata fields */
-interface ChatReasoningPart {
+export interface ChatReasoningPart {
     type: 'reasoning';
     text: string;
     id?: string;
@@ -81,9 +80,9 @@ interface ChatReasoningPart {
 /** Superset of the sidecar's status enum (`pending|running|completed|failed`)
  *  and agent-interface's `ToolState` statuses; `error` is the persisted
  *  terminal form `/stream`'s `normalizePersistedPart` settles on. */
-type ChatToolStatus = 'pending' | 'running' | 'completed' | 'error' | 'failed';
+export type ChatToolStatus = 'pending' | 'running' | 'completed' | 'error' | 'failed';
 /** Describe the current state and data of a chat tool including status, input, output, and metadata */
-interface ChatToolState {
+export interface ChatToolState {
     status: ChatToolStatus;
     input?: unknown;
     output?: unknown;
@@ -93,7 +92,7 @@ interface ChatToolState {
     time?: ChatPartTime;
 }
 /** Define a chat component representing a tool with its state and optional call identifier */
-interface ChatToolPart {
+export interface ChatToolPart {
     type: 'tool';
     id: string;
     tool: string;
@@ -105,7 +104,7 @@ interface ChatToolPart {
  *  attachment-flavored display label an uploaded/promoted file carries (see
  *  {@link ChatAttachmentPart}) — absent on a harness-emitted file part, which
  *  uses `filename`. */
-interface ChatFilePart {
+export interface ChatFilePart {
     type: 'file';
     id?: string;
     filename?: string;
@@ -116,7 +115,7 @@ interface ChatFilePart {
     content?: string;
 }
 /** Define properties for an image part within a chat message including optional metadata fields */
-interface ChatImagePart {
+export interface ChatImagePart {
     type: 'image';
     filename?: string;
     name?: string;
@@ -125,7 +124,7 @@ interface ChatImagePart {
     path?: string;
 }
 /** Define a subtask part of a chat with prompt, description, agent, and optional identifier */
-interface ChatSubtaskPart {
+export interface ChatSubtaskPart {
     type: 'subtask';
     prompt: string;
     description: string;
@@ -134,13 +133,13 @@ interface ChatSubtaskPart {
 }
 /** OpenCode step-boundary marker — no renderable text; preserved so mappers
  *  never coerce it into a "[object Object]" text part. */
-interface ChatStepStartPart {
+export interface ChatStepStartPart {
     type: 'step-start';
 }
 /** Per-step usage receipt as the harness reports it (sidecar
  *  `StepFinishPartSchema`). The message-level token/cost columns are this
  *  shape flattened. */
-interface ChatUsageTokens {
+export interface ChatUsageTokens {
     total?: number;
     input?: number;
     output?: number;
@@ -151,7 +150,7 @@ interface ChatUsageTokens {
     };
 }
 /** Define a chat step finish part indicating completion with optional reason, tokens, and cost */
-interface ChatStepFinishPart {
+export interface ChatStepFinishPart {
     type: 'step-finish';
     reason?: string;
     tokens?: ChatUsageTokens;
@@ -159,7 +158,7 @@ interface ChatStepFinishPart {
 }
 /** Persisted human-in-the-loop ask — byte-matches
  *  `interactionToPersistedPart` in `/web-react`'s chat-interactions contract. */
-interface ChatInteractionPart {
+export interface ChatInteractionPart {
     type: 'interaction';
     id: string;
     kind: string;
@@ -173,15 +172,15 @@ interface ChatInteractionPart {
     cancelReason?: string;
 }
 /** Resolve a chat plan part by aliasing it to the persisted chat plan part type */
-type ChatPlanPart = ChatPlanPersistedPart;
+export type ChatPlanPart = ChatPlanPersistedPart;
 /** Persisted work-product anchor card — byte-matches
  *  `workProductToPersistedPart` in `/work-product`'s contract. Written by the
  *  PLATFORM on the ready transition (and updated on a verdict); never
  *  authored by a prompt. */
-type ChatWorkProductPart = WorkProductPersistedPart;
+export type ChatWorkProductPart = WorkProductPersistedPart;
 /** Persisted one-line transcript notice — byte-matches `noticePart` in
  *  `/web-react`'s chat-interactions contract. */
-interface ChatNoticePart {
+export interface ChatNoticePart {
     type: 'notice';
     id: string;
     noticeKind: NoticeKind;
@@ -199,7 +198,7 @@ interface ChatNoticePart {
  * part. `turnId` is optional and set by products that rebuild a turn's
  * mentions on retry.
  */
-interface ChatMentionPart {
+export interface ChatMentionPart {
     type: 'mention';
     mentionKind: ChatMentionKind;
     path: string;
@@ -208,11 +207,11 @@ interface ChatMentionPart {
     turnId?: string;
 }
 /** Represent parts of a chat message including text, reasoning, tools, files, images, subtasks, steps, interactions, notices, plans, and mentions */
-type ChatMessagePart = ChatTextPart | ChatReasoningPart | ChatToolPart | ChatFilePart | ChatImagePart | ChatSubtaskPart | ChatStepStartPart | ChatStepFinishPart | ChatInteractionPart | ChatNoticePart | ChatPlanPart | ChatWorkProductPart | ChatMentionPart;
+export type ChatMessagePart = ChatTextPart | ChatReasoningPart | ChatToolPart | ChatFilePart | ChatImagePart | ChatSubtaskPart | ChatStepStartPart | ChatStepFinishPart | ChatInteractionPart | ChatNoticePart | ChatPlanPart | ChatWorkProductPart | ChatMentionPart;
 /** Every canonical harness wire-part kind must be storable — compile-time
  *  guarantee that a new agent-interface part kind cannot silently fall out of
  *  the persisted vocabulary. */
-type StorableHarnessPartKind = Part['type'] & ChatMessagePart['type'];
+export type StorableHarnessPartKind = HarnessWirePart['type'] & ChatMessagePart['type'];
 /**
  * The typed projection at the `/stream` → `/chat-store` boundary. The stream
  * normalizers (`normalizePersistedPart`/`mergePersistedPart`/
@@ -223,19 +222,19 @@ type StorableHarnessPartKind = Part['type'] & ChatMessagePart['type'];
  * dropped, and — enforced by the exhaustiveness check below — no storable
  * kind can silently fall out (the step-finish/interaction trap).
  */
-declare function toChatMessageParts(parts: Array<Record<string, unknown>>): ChatMessagePart[];
+export declare function toChatMessageParts(parts: Array<Record<string, unknown>>): ChatMessagePart[];
 /** Resolve whether a ChatMessagePart is specifically a ChatToolPart based on its type property */
-declare function isChatToolPart(part: ChatMessagePart): part is ChatToolPart;
+export declare function isChatToolPart(part: ChatMessagePart): part is ChatToolPart;
 /** Resolve whether a chat message part is a text part based on its type property */
-declare function isChatTextPart(part: ChatMessagePart): part is ChatTextPart;
+export declare function isChatTextPart(part: ChatMessagePart): part is ChatTextPart;
 /** Resolve whether a ChatMessagePart is a ChatInteractionPart based on its type property */
-declare function isChatInteractionPart(part: ChatMessagePart): part is ChatInteractionPart;
+export declare function isChatInteractionPart(part: ChatMessagePart): part is ChatInteractionPart;
 /** Resolve whether a chat message part is a persisted chat plan part */
-declare function isChatPlanPart(part: ChatMessagePart): part is ChatPlanPart;
+export declare function isChatPlanPart(part: ChatMessagePart): part is ChatPlanPart;
 /** Resolve whether a chat message part is a persisted work-product anchor */
-declare function isChatWorkProductPart(part: ChatMessagePart): part is ChatWorkProductPart;
+export declare function isChatWorkProductPart(part: ChatMessagePart): part is ChatWorkProductPart;
 /** Determine if a chat message part represents the completion of a chat step */
-declare function isChatStepFinishPart(part: ChatMessagePart): part is ChatStepFinishPart;
+export declare function isChatStepFinishPart(part: ChatMessagePart): part is ChatStepFinishPart;
 /** Widened to `unknown` — unlike its siblings this guard also runs over raw
  *  untyped stored rows (a transcript renderer reads `message.parts` before the
  *  typed projection), which is exactly what {@link mentionPartsFromMessageParts}
@@ -248,21 +247,26 @@ declare function isChatStepFinishPart(part: ChatMessagePart): part is ChatStepFi
  *  type it does not have. Negative sizes are NOT re-rejected: the wire screens
  *  them, `mentionInputToPart` trusts its input, and a read guard stricter than
  *  what the writer can emit would drop rows it produced itself. */
-declare function isChatMentionPart(part: unknown): part is ChatMentionPart;
+export declare function isChatMentionPart(part: unknown): part is ChatMentionPart;
 /** Every mention part on one message, in stored order. The projection a
  *  transcript renderer runs before deciding which mentions the message text
  *  already shows inline (see `segmentMentionContent` in `/web-react`). */
-declare function mentionPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | ReadonlyArray<ChatMessagePart> | null | undefined): ChatMentionPart[];
+export declare function mentionPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | ReadonlyArray<ChatMessagePart> | null | undefined): ChatMentionPart[];
 /** A validated wire mention (`parseFileMentions` in `/chat-routes`) as the
  *  part the turn route persists. An absent/non-finite `size` is DROPPED rather
  *  than stored as `undefined`, so a stored row never carries a key that means
  *  nothing. */
-declare function mentionInputToPart(input: FileMention): ChatMentionPart;
+export declare function mentionInputToPart(input: FileMention): ChatMentionPart;
 /** `image` for any `image/*` mime, `file` for everything else (including an
  *  absent/empty mime) — the same split the composer and the persisted-part
  *  discriminant both key on. */
-declare function attachmentKindForMime(mime?: string): ChatAttachmentKind;
-
+export declare function attachmentKindForMime(mime?: string): ChatAttachmentKind;
+/** Stream/transcript part key for an attachment — ONE declaration, owned by
+ *  `/stream`'s normalizer (whose `getPartKey` routes path-bearing file/image
+ *  parts through it). Re-exported here (not redefined) so the root barrel's
+ *  star-exports of both modules resolve to the same symbol instead of
+ *  colliding (TS2308 in the dts build). */
+export { attachmentPartKey } from '../stream/stream-normalizer';
 /**
  * Persisted attachment part: structurally an attachment-flavored `ChatFilePart`
  * / `ChatImagePart` (`path` + `name` promoted to required) rather than a
@@ -271,7 +275,7 @@ declare function attachmentKindForMime(mime?: string): ChatAttachmentKind;
  * arrays every other stored part rides in, and lets the `type`-driven
  * constructors below build it without union-discriminant gymnastics.
  */
-interface ChatAttachmentPart {
+export interface ChatAttachmentPart {
     type: ChatAttachmentKind;
     path: string;
     name: string;
@@ -290,16 +294,16 @@ interface ChatAttachmentPart {
  *  would otherwise render a malformed `(vault: )` pointer line — justifies the
  *  small divergence from byte-for-byte gtm parity here; no legitimate write
  *  path ever produces an empty `path`. */
-declare function isChatAttachmentPart(part: unknown): part is ChatAttachmentPart;
+export declare function isChatAttachmentPart(part: unknown): part is ChatAttachmentPart;
 /** Drop absent/empty optional fields rather than persisting `undefined`/`''`
  *  — keeps stored parts minimal. */
-declare function attachmentInputToPart(input: ChatAttachmentInput): ChatAttachmentPart;
+export declare function attachmentInputToPart(input: ChatAttachmentInput): ChatAttachmentPart;
 /** Every attachment part on one message's stored `parts`, in stored order. */
-declare function attachmentPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | null | undefined): ChatAttachmentPart[];
+export declare function attachmentPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | null | undefined): ChatAttachmentPart[];
 /** gtm's exact default header for {@link buildAttachmentPromptBlock} — kept
  *  byte-identical because it feeds dispatched prompts (gtm-agent#618
  *  reproduces the prompt bytes through this module). Override only with intent. */
-declare const DEFAULT_ATTACHMENT_PROMPT_HEADER = "Attached files (already saved to the workspace vault \u2014 read them from these paths):";
+export declare const DEFAULT_ATTACHMENT_PROMPT_HEADER = "Attached files (already saved to the workspace vault \u2014 read them from these paths):";
 /**
  * The agent-facing pointer block appended to the dispatched prompt — never
  * persisted in `message.content`. Empty array → `''` so callers can append
@@ -318,7 +322,7 @@ declare const DEFAULT_ATTACHMENT_PROMPT_HEADER = "Attached files (already saved
  * The wire-side validator is the primary control; this is the backstop for
  * rows it never saw.
  */
-declare function buildAttachmentPromptBlock(atts: ReadonlyArray<Pick<ChatAttachmentPart, 'name' | 'path'>>, header?: string): string;
+export declare function buildAttachmentPromptBlock(atts: ReadonlyArray<Pick<ChatAttachmentPart, 'name' | 'path'>>, header?: string): string;
 /**
  * History projection for a persisted message: `content` unchanged when it
  * carries no attachment parts, else the block is appended once. The
@@ -331,9 +335,7 @@ declare function buildAttachmentPromptBlock(atts: ReadonlyArray<Pick<ChatAttachm
  * contain the block's bytes, alongside attachment parts, still gets the block
  * appended a second time. See the pinned test for that boundary.
  */
-declare function historyContentWithAttachments(message: {
+export declare function historyContentWithAttachments(message: {
     content: string;
     parts?: ReadonlyArray<Record<string, unknown>> | null;
 }, header?: string): string;
-
-export { isChatPlanPart as A, isChatStepFinishPart as B, type ChatMessagePart as C, DEFAULT_ATTACHMENT_PROMPT_HEADER as D, isChatTextPart as E, isChatToolPart as F, isChatWorkProductPart as G, mentionInputToPart as H, mentionPartsFromMessageParts as I, toChatMessageParts as J, type StorableHarnessPartKind as S, type ChatAttachmentPart as a, type ChatFilePart as b, type ChatImagePart as c, type ChatInteractionPart as d, type ChatMentionPart as e, type ChatNoticePart as f, type ChatPartTime as g, type ChatPlanPart as h, type ChatReasoningPart as i, type ChatStepFinishPart as j, type ChatStepStartPart as k, type ChatSubtaskPart as l, type ChatTextPart as m, type ChatToolPart as n, type ChatToolState as o, type ChatToolStatus as p, type ChatUsageTokens as q, type ChatWorkProductPart as r, attachmentInputToPart as s, attachmentKindForMime as t, attachmentPartsFromMessageParts as u, buildAttachmentPromptBlock as v, historyContentWithAttachments as w, isChatAttachmentPart as x, isChatInteractionPart as y, isChatMentionPart as z };

package/dist/chat-store/schema.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Drizzle schema factory for the chat thread/message tables — the same
+ * injection pattern as `createTeamTables`: the product owns the workspace
+ * table; the factory wires the thread FK into it so the whole graph lives in
+ * one drizzle schema with real cascade semantics. Column names, types,
+ * defaults, enums, and indexes mirror legal's and gtm's hand-rolled `thread`/
+ * `message` tables so a product with those tables adopts the factory without
+ * rewriting rows; `tablePrefix` covers products that namespace (tax's
+ * `chat_messages` style).
+ *
+ * The core is the superset the three products agree on. Divergences dropped,
+ * and why:
+ * - `thread.status` ('active'|'archived', legal+gtm) — archive semantics
+ *   diverge (tax uses `archivedAt`); product-domain lifecycle → extra column.
+ * - `thread.scopeKind`/`scopeKey`/`harness` (gtm) — artifact anchoring and
+ *   harness pinning are product-domain → extra columns.
+ * - tax's `tax_sessions` session columns (`taxYear`, `projectRef`,
+ *   `agentSessionId`, `agentRuntime`, `agentHarness`, `profile`, `error`,
+ *   `userId`) — sandbox-session state, not chat state → extra columns.
+ * - `message.toolInput`/`toolOutput` (legal+gtm) — duplicate of the tool
+ *   part's `state.input`/`state.output` inside `parts` (the shape `/stream`'s
+ *   `normalizePersistedPart` owns); keeping both invites drift.
+ * - `message.vaultFiles` (legal+gtm) — vault is product-domain → extra column.
+ * - tax's re-declared `turn_events`/`turn_status` DDL — deliberately NOT here;
+ *   `/stream`'s turn-buffer owns that DDL (`TURN_BUFFER_D1_SCHEMA_SQL`).
+ *
+ * Kept beyond the intersection: tax's per-message `model`/`inputTokens`/
+ * `outputTokens`, extended to the full usage receipt the harness actually
+ * reports in `step-finish` parts (`tokens {input, output, reasoning,
+ * cache{read, write}}` + `cost`) — see `./parts`.
+ *
+ * `threadExtraColumns`/`messageExtraColumns` merge product columns into the
+ * table definitions (the `/missions` opaque-extras pattern: the store writes
+ * `extras` values verbatim in the SAME insert statement and never reads,
+ * validates, or defaults them).
+ *
+ * SERVER-side module (D1/libsql/better-sqlite3 behind a worker or server
+ * route) — but free of `node:` builtins on purpose: D1 workers have none.
+ */
+import type { AnySQLiteColumn, AnySQLiteTable, SQLiteColumnBuilderBase, SQLiteTableExtraConfigValue } from 'drizzle-orm/sqlite-core';
+import type { ChatMessagePart } from './parts';
+/** A product table referenced by FK — only the `id` column is touched. */
+export type ChatParentTable = AnySQLiteTable & {
+    id: AnySQLiteColumn;
+};
+/** Define options to customize chat thread and message table creation including workspace and naming prefixes */
+export interface CreateChatTablesOptions<TThreadExtras extends Record<string, SQLiteColumnBuilderBase> = {}, TMessageExtras extends Record<string, SQLiteColumnBuilderBase> = {}> {
+    /** The product's workspace table — threads reference `workspaceTable.id`
+     *  with cascade. Omitted: `workspace_id` stays a plain indexed text column
+     *  (products whose tenant table lives in another database). */
+    workspaceTable?: ChatParentTable;
+    /** Prefixes table AND index names (`'chat_'` → `chat_thread`,
+     *  `idx_chat_thread_workspace`) for products that namespace chat tables in a
+     *  shared database. Default: unprefixed `thread`/`message` (legal/gtm row
+     *  compatibility). */
+    tablePrefix?: string;
+    /** Product columns merged into the thread table (the `/missions` extras
+     *  pattern) — e.g. a `status` lifecycle enum or gtm's scope columns. */
+    threadExtraColumns?: TThreadExtras;
+    /** Product columns merged into the message table — e.g. legal's
+     *  `vault_files`. */
+    messageExtraColumns?: TMessageExtras;
+    /**
+     * Product indexes appended to the thread table's own, given the built
+     * columns (extras included) so a product can index what it added.
+     *
+     * Names are used VERBATIM — `tablePrefix` is not applied — because these
+     * have to byte-match indexes the product's migrations already created.
+     *
+     * Without this a product with one extra index cannot adopt the factory at
+     * all: it keeps a hand-rolled duplicate of the same physical table, and the
+     * two drift on the next factory change.
+     */
+    threadExtraIndexes?: ChatExtraIndexes;
+    /** Product indexes appended to the message table's own. Same rules as
+     *  `threadExtraIndexes`. */
+    messageExtraIndexes?: ChatExtraIndexes;
+}
+/**
+ * Builds product indexes from a table's columns.
+ *
+ * The column map is passed untyped because its shape depends on the product's
+ * own extras; the RETURN is drizzle's own extra-config type, so the spread
+ * below stays inside the union `sqliteTable` expects and the built table keeps
+ * its inferred column types. Returning `unknown[]` here would force a cast on
+ * the config array, which widens every column to the cross-dialect union and
+ * breaks `db.select()` at every call site.
+ */
+export type ChatExtraIndexes = (columns: Record<string, AnySQLiteColumn>) => SQLiteTableExtraConfigValue[];
+/** Build chat-related SQLite tables with customizable thread and message columns */
+export declare function createChatTables<TThreadExtras extends Record<string, SQLiteColumnBuilderBase> = {}, TMessageExtras extends Record<string, SQLiteColumnBuilderBase> = {}>(options?: CreateChatTablesOptions<TThreadExtras, TMessageExtras>): {
+    threads: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: `${string}thread`;
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm").HasDefault<import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>>;
+            workspaceId: import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"workspace_id", [string, ...string[]], number | undefined>>;
+            title: import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"title", [string, ...string[]], number | undefined>>;
+            category: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"category", [string, ...string[]], number | undefined>;
+            isPinned: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteBooleanBuilderInitial<"is_pinned">>>;
+            createdAt: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTimestampBuilderInitial<"created_at">>>;
+            updatedAt: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTimestampBuilderInitial<"updated_at">>>;
+        } & TThreadExtras extends infer T extends Record<string, import("drizzle-orm").ColumnBuilderBase<import("drizzle-orm").ColumnBuilderBaseConfig<import("drizzle-orm").ColumnDataType, string>, object>> ? { [Key in keyof T]: import("drizzle-orm").BuildColumn<TTableName, {
+            _: Omit<T[Key]["_"], "name"> & {
+                name: T[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : T[Key]["_"]["name"];
+            };
+        }, TDialect>; } : never;
+        dialect: "sqlite";
+    }>;
+    messages: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: `${string}message`;
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm").HasDefault<import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>>;
+            threadId: import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"thread_id", [string, ...string[]], number | undefined>>;
+            role: import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"role", ["user", "assistant", "system", "tool"], number | undefined>>;
+            content: import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"content", [string, ...string[]], number | undefined>>;
+            parts: import("drizzle-orm").HasDefault<import("drizzle-orm").$Type<import("drizzle-orm/sqlite-core").SQLiteTextJsonBuilderInitial<"parts">, ChatMessagePart[]>>;
+            toolName: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"tool_name", [string, ...string[]], number | undefined>;
+            model: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"model", [string, ...string[]], number | undefined>;
+            requestedModel: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"requested_model", [string, ...string[]], number | undefined>;
+            servedModel: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"served_model", [string, ...string[]], number | undefined>;
+            servedProvider: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"served_provider", [string, ...string[]], number | undefined>;
+            servedSource: import("drizzle-orm/sqlite-core").SQLiteTextBuilderInitial<"served_model_source", [string, ...string[]], number | undefined>;
+            inputTokens: import("drizzle-orm/sqlite-core").SQLiteIntegerBuilderInitial<"input_tokens">;
+            outputTokens: import("drizzle-orm/sqlite-core").SQLiteIntegerBuilderInitial<"output_tokens">;
+            reasoningTokens: import("drizzle-orm/sqlite-core").SQLiteIntegerBuilderInitial<"reasoning_tokens">;
+            cacheReadTokens: import("drizzle-orm/sqlite-core").SQLiteIntegerBuilderInitial<"cache_read_tokens">;
+            cacheWriteTokens: import("drizzle-orm/sqlite-core").SQLiteIntegerBuilderInitial<"cache_write_tokens">;
+            costUsd: import("drizzle-orm/sqlite-core").SQLiteRealBuilderInitial<"cost_usd">;
+            createdAt: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/sqlite-core").SQLiteTimestampBuilderInitial<"created_at">>>;
+        } & TMessageExtras extends infer T_1 extends Record<string, import("drizzle-orm").ColumnBuilderBase<import("drizzle-orm").ColumnBuilderBaseConfig<import("drizzle-orm").ColumnDataType, string>, object>> ? { [Key_1 in keyof T_1]: import("drizzle-orm").BuildColumn<TTableName, {
+            _: Omit<T_1[Key_1]["_"], "name"> & {
+                name: T_1[Key_1]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key_1, string> : T_1[Key_1]["_"]["name"];
+            };
+        }, TDialect>; } : never;
+        dialect: "sqlite";
+    }>;
+};
+/**
+ * The base (no-extras) table pair, pinned via an instantiation expression:
+ * `ReturnType<typeof createChatTables>` on the bare generic substitutes the
+ * extras params with their CONSTRAINT (`Record<string,
+ * SQLiteColumnBuilderBase>`), stamping an index signature into the column map
+ * that widens every concrete column to `unknown`/`notNull: false` — concrete
+ * factory results then fail `extends ChatTables`. (`teams`' `createTeamTables`
+ * is non-generic, so its plain `ReturnType` never hits this.)
+ */
+export type ChatTables = ReturnType<typeof createChatTables<{}, {}>>;
+/** Resolve the selected fields of a chat thread row from the chat threads table */
+export type ChatThreadRow = ChatTables['threads']['$inferSelect'];
+/** Resolve the selected structure of a chat message row from the messages table */
+export type ChatMessageRow = ChatTables['messages']['$inferSelect'];
+/** Resolve the type for inserting a new chat thread row into the threads table */
+export type NewChatThreadRow = ChatTables['threads']['$inferInsert'];
+/** Resolve the type for inserting a new chat message row into the messages table */
+export type NewChatMessageRow = ChatTables['messages']['$inferInsert'];

package/dist/chat-store/store.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Typed CRUD over the tables from `createChatTables`. Works against any
+ * SQLite drizzle driver (D1, libsql, better-sqlite3) — builders are awaited,
+ * never `.run()`/`.all()`, so sync and async drivers behave identically.
+ *
+ * Access control is an injected seam, never an import: single-thread routes
+ * check workspace access themselves (they know the thread), while
+ * `bulkDeleteThreads` REQUIRES an `assertAccess` callback because one request
+ * can span workspaces — it is called once per distinct workspace and any
+ * throw rejects the whole request before a single delete runs (fail-closed;
+ * legal's bulk-delete semantics).
+ *
+ * Deletes run messages-first in ONE `db.batch` round trip when the driver has
+ * one (D1, libsql), so a partial failure never leaves orphaned rows behind a
+ * deleted thread; drivers without `batch` (better-sqlite3) fall back to
+ * sequential awaits in the same order.
+ */
+import { type SQL } from 'drizzle-orm';
+import type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { type SqliteBatchDatabase } from '../store';
+import type { ChatMessagePart } from './parts';
+import type { ChatMessageRow, ChatTables, ChatThreadRow } from './schema';
+/** Any SQLite drizzle database — `any` erases the driver-specific run-result
+ *  and schema generics so better-sqlite3, D1, and libsql handles all fit.
+ *  `batch` is structural: present on D1/libsql drizzle instances. */
+export type ChatDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any> & SqliteBatchDatabase;
+/** Product-injected access check. Throw to deny; the store never interprets
+ *  users or roles itself. */
+export type WorkspaceAccessCheck = (workspaceId: string) => void | Promise<void>;
+/** Define input parameters for listing threads within a workspace with pagination options */
+export interface ListThreadsInput {
+    workspaceId: string;
+    /** Clamped to 1..200; default 50 (legal's list route semantics). */
+    limit?: number;
+    /** Clamped to >= 0; default 0. */
+    offset?: number;
+}
+/** Represent a paginated collection of chat threads with total count and pagination details */
+export interface ListThreadsResult<TThread = ChatThreadRow> {
+    threads: TThread[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/** Define input parameters required to create a new thread in a workspace */
+export interface CreateThreadInput {
+    workspaceId: string;
+    /** Title source when `title` is absent: first non-empty line, 80-char cap
+     *  (`threadTitleFromMessage`). */
+    firstMessage?: string;
+    /** Explicit title; still normalized through `threadTitleFromMessage` so a
+     *  multi-page paste never becomes a sidebar entry. */
+    title?: string;
+    category?: string | null;
+    isPinned?: boolean;
+    /** Opaque product-column values written verbatim in the SAME insert (the
+     *  `/missions` extras pattern). Never read, validated, or defaulted here. */
+    extras?: Record<string, unknown>;
+}
+/** Define input parameters for appending a message to a chat thread with optional metadata */
+export interface AppendMessageInput {
+    /** Caller-assigned primary key. Omitted, the column default assigns a random
+     *  hex id (today's behavior). Incremental assistant persistence passes a
+     *  DETERMINISTIC id derived from the turn's own identity, so a re-entered
+     *  turn (crashed worker, durable-driver retry) finds and updates the row a
+     *  previous attempt started instead of inserting a second one. */
+    id?: string;
+    threadId: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    parts?: ChatMessagePart[];
+    toolName?: string | null;
+    model?: string | null;
+    requestedModel?: string | null;
+    servedModel?: string | null;
+    servedProvider?: string | null;
+    servedSource?: string | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    reasoningTokens?: number | null;
+    cacheReadTokens?: number | null;
+    cacheWriteTokens?: number | null;
+    costUsd?: number | null;
+    /** Opaque product-column values written verbatim in the SAME insert. */
+    extras?: Record<string, unknown>;
+}
+/** Fields an existing message row may be patched with. Every field is
+ *  optional and only DEFINED fields are written, so a partial patch never
+ *  clears a column it does not mention. `threadId` and `role` are absent on
+ *  purpose: a message never moves thread or changes speaker.
+ *
+ *  Exists for incremental assistant persistence — the streaming turn writes
+ *  the row once and then patches it as content accumulates, so the durable
+ *  transcript is at most one cadence interval behind the live stream. */
+export interface UpdateMessageInput {
+    content?: string;
+    parts?: ChatMessagePart[];
+    toolName?: string | null;
+    model?: string | null;
+    requestedModel?: string | null;
+    servedModel?: string | null;
+    servedProvider?: string | null;
+    servedSource?: string | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    reasoningTokens?: number | null;
+    cacheReadTokens?: number | null;
+    cacheWriteTokens?: number | null;
+    costUsd?: number | null;
+    /** Opaque product-column values written verbatim in the SAME update. */
+    extras?: Record<string, unknown>;
+}
+/** Define options to configure message listing with optional limit and offset parameters */
+export interface ListMessagesOptions {
+    limit?: number;
+    offset?: number;
+}
+/** Define input for bulk deleting threads with access checks per workspace */
+export interface BulkDeleteThreadsInput {
+    ids: string[];
+    /** Optional single-workspace fence for products whose route already resolved
+     *  one active workspace. Omitted preserves the multi-workspace legal route. */
+    workspaceId?: string;
+    /** Called once per distinct workspace the ids touch, before ANY delete. */
+    assertAccess: WorkspaceAccessCheck;
+}
+/** Delete threads selected by their last activity time within one workspace.
+ *
+ * Products can add a lifecycle predicate such as `status = 'active'` through
+ * `where`; the store still owns workspace scope, access ordering, and message
+ * cleanup for every consumer. */
+export interface BulkDeleteThreadsByUpdatedAtInput {
+    workspaceId: string;
+    /** Exclusive upper bound: rows older than this instant. */
+    updatedBefore?: Date;
+    /** Inclusive lower bound: rows updated at or after this instant. */
+    updatedAfter?: Date;
+    where?: SQL;
+    /** Called before any delete for the requested workspace. */
+    assertAccess: WorkspaceAccessCheck;
+}
+/** Manage chat threads and messages with operations for listing, creating, updating, and deleting data */
+export interface ChatStore<TThread = ChatThreadRow, TMessage = ChatMessageRow> {
+    listThreads(input: ListThreadsInput): Promise<ListThreadsResult<TThread>>;
+    getThread(threadId: string): Promise<TThread | null>;
+    createThread(input: CreateThreadInput): Promise<TThread>;
+    renameThread(threadId: string, title: string): Promise<TThread | null>;
+    pinThread(threadId: string, isPinned: boolean): Promise<TThread | null>;
+    /** Messages + thread in one batch. Resolves false when the thread does not
+     *  exist. `assertAccess` (optional) receives the thread's workspaceId before
+     *  the delete — single-thread callers usually check access themselves. */
+    deleteThread(threadId: string, options?: {
+        assertAccess?: WorkspaceAccessCheck;
+    }): Promise<boolean>;
+    bulkDeleteThreads(input: BulkDeleteThreadsInput): Promise<{
+        deleted: number;
+    }>;
+    bulkDeleteThreadsByUpdatedAt(input: BulkDeleteThreadsByUpdatedAtInput): Promise<{
+        deleted: number;
+    }>;
+    /** Ordered oldest-first: `created_at`, then rowid (insertion order within a
+     *  same-second burst — a user+assistant pair lands in one epoch second). */
+    listMessages(threadId: string, options?: ListMessagesOptions): Promise<TMessage[]>;
+    /** Inserts the message and bumps the thread's `updatedAt` in one batch so
+     *  workspace recency sorts stay truthful. */
+    appendMessage(input: AppendMessageInput): Promise<TMessage>;
+    /** Patches an existing message and bumps its thread's `updatedAt` in the
+     *  same batch. Resolves `null` when the id does not exist. Only defined
+     *  patch fields are written. */
+    updateMessage(id: string, patch: UpdateMessageInput): Promise<TMessage | null>;
+    /** Removes one message. Resolves false when the id does not exist. Used by
+     *  incremental persistence to retract a draft row for a turn that ended
+     *  producing nothing, so an empty assistant row is never left behind. */
+    deleteMessage(id: string): Promise<boolean>;
+}
+/** Create a chat store managing threads and messages based on the provided database and tables */
+export declare function createChatStore<TTables extends ChatTables>(db: ChatDatabase, tables: TTables): ChatStore<TTables['threads']['$inferSelect'], TTables['messages']['$inferSelect']>;