@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/{wire-DOZ-O6hD.d.ts → chat-routes/wire.d.ts}

@@ -1,5 +1,4 @@
-import { ReasoningEffort } from '@tangle-network/agent-interface';
-
+import type { ReasoningEffort } from '@tangle-network/agent-interface';
 /**
  * Wire contract between the chat client (composer + `streamChatTurn`) and the
  * assembled server vertical (`createChatTurnRoutes`). Runtime-import-free on
@@ -10,7 +9,7 @@ import { ReasoningEffort } from '@tangle-network/agent-interface';
  * it to the URL required by the sandbox SDK. It is derived here, not imported,
  * so the client bundle never touches the SDK.
  */
-interface ChatTurnTextPartInput {
+export interface ChatTurnTextPartInput {
     type: 'text';
     text: string;
 }
@@ -18,7 +17,7 @@ interface ChatTurnTextPartInput {
  *  on send. `url` carries an inline `data:` URI for small files; `path` is a
  *  sandbox workspace reference for large ones (the >1 MiB gateway body cap
  *  makes the two-step upload mandatory). */
-interface ChatTurnFilePartInput {
+export interface ChatTurnFilePartInput {
     type: 'image' | 'file';
     filename?: string;
     mediaType?: string;
@@ -26,21 +25,21 @@ interface ChatTurnFilePartInput {
     path?: string;
 }
 /** Resolve input as either a text part or a file part of a chat turn */
-type ChatTurnPartInput = ChatTurnTextPartInput | ChatTurnFilePartInput;
+export type ChatTurnPartInput = ChatTurnTextPartInput | ChatTurnFilePartInput;
 /** A chat turn's automatic sentinel plus the canonical agent reasoning levels. */
-type ChatReasoningEffort = 'auto' | ReasoningEffort;
+export type ChatReasoningEffort = 'auto' | ReasoningEffort;
 /** Represent a text event produced by a source with a fixed type and associated text content */
-interface ProducerTextEvent {
+export interface ProducerTextEvent {
     type: 'text';
     text: string;
 }
 /** Define an event representing reasoning output with a fixed type and associated text */
-interface ProducerReasoningEvent {
+export interface ProducerReasoningEvent {
     type: 'reasoning';
     text: string;
 }
 /** Represent an event triggered by a producer tool call with its identifier, name, and arguments */
-interface ProducerToolCallEvent {
+export interface ProducerToolCallEvent {
     type: 'tool_call';
     call: {
         toolCallId: string;
@@ -49,7 +48,7 @@ interface ProducerToolCallEvent {
     };
 }
 /** Describe the structure of an event representing the result of a producer tool call */
-interface ProducerToolResultEvent {
+export interface ProducerToolResultEvent {
     type: 'tool_result';
     toolCallId: string;
     toolName: string;
@@ -60,7 +59,7 @@ interface ProducerToolResultEvent {
     };
 }
 /** Describe usage event with prompt and completion token counts for a producer */
-interface ProducerUsageEvent {
+export interface ProducerUsageEvent {
     type: 'usage';
     usage: {
         promptTokens: number;
@@ -68,7 +67,7 @@ interface ProducerUsageEvent {
     };
 }
 /** Define the structure for a producer notice event with type, id, kind, and text fields */
-interface ProducerNoticeEvent {
+export interface ProducerNoticeEvent {
     type: 'notice';
     id: string;
     /** Kept inline with `/interactions`' `NoticeKind` so this file stays import-free. */
@@ -76,7 +75,7 @@ interface ProducerNoticeEvent {
     text: string;
 }
 /** Represent an error event emitted by a producer containing message, code, and optional details */
-interface ProducerErrorEvent {
+export interface ProducerErrorEvent {
     type: 'error';
     data: {
         message: string;
@@ -85,16 +84,16 @@ interface ProducerErrorEvent {
     };
 }
 /** Stable raw lifecycle/interaction/plan/route events forwarded unchanged. */
-type ProducerPassthroughEventType = 'turn' | 'metadata' | 'interaction' | 'interaction.cancel' | 'plan.submitted' | 'done' | 'warning' | 'session.run.started' | 'session.run.completed' | 'session.run.failed' | 'turn_status';
+export type ProducerPassthroughEventType = 'turn' | 'metadata' | 'interaction' | 'interaction.cancel' | 'plan.submitted' | 'done' | 'warning' | 'session.run.started' | 'session.run.completed' | 'session.run.failed' | 'turn_status';
 /** Define an event carrying passthrough data with flexible properties for producer communication */
-interface ProducerPassthroughEvent {
+export interface ProducerPassthroughEvent {
     type: ProducerPassthroughEventType;
     data?: Record<string, unknown>;
     /** Route markers and raw passthroughs may carry `turnId`, `status`, `seq`, etc. */
     [key: string]: unknown;
 }
 /** Represent events emitted by a producer during its operation for processing and handling */
-type ProducerWireEvent = ProducerTextEvent | ProducerReasoningEvent | ProducerToolCallEvent | ProducerToolResultEvent | ProducerUsageEvent | ProducerNoticeEvent | ProducerErrorEvent | ProducerPassthroughEvent;
+export type ProducerWireEvent = ProducerTextEvent | ProducerReasoningEvent | ProducerToolCallEvent | ProducerToolResultEvent | ProducerUsageEvent | ProducerNoticeEvent | ProducerErrorEvent | ProducerPassthroughEvent;
 /** The image/file split an attachment is rendered and persisted under — the
  *  same discriminant as {@link ChatMentionKind}, but a distinct name because an
  *  attachment carries content the product uploaded (`ChatAttachmentInput`)
@@ -102,14 +101,14 @@ type ProducerWireEvent = ProducerTextEvent | ProducerReasoningEvent | ProducerTo
  *  import-free layer) so `ChatAttachmentInput` can reference it and the client
  *  composer imports it without pulling the persisted-part vocabulary;
  *  `/chat-store`'s parts module re-exports it alongside the attachment helpers. */
-type ChatAttachmentKind = 'image' | 'file';
+export type ChatAttachmentKind = 'image' | 'file';
 /** `POST` turn-body entry describing a file already uploaded to the product's
  *  store (vault/object-store) — distinct from an inline {@link
  *  ChatTurnFilePartInput} (which carries bytes) and from a {@link FileMention}
  *  (a sandbox path the box already holds). The route resolves this field with
  *  {@link resolveChatAttachments}: every path is re-validated and every size is
  *  re-derived from the stored body, so nothing here is trusted as sent. */
-interface ChatAttachmentInput {
+export interface ChatAttachmentInput {
     path: string;
     name: string;
     size: number;
@@ -119,7 +118,7 @@ interface ChatAttachmentInput {
 /** POST body for the turn route. `content` may be empty when `parts` carry the
  *  message (an image-only send). Product routing fields (workspaceId etc.) ride
  *  alongside and are read by the product's `authorize` seam. */
-interface ChatTurnRequestPayload {
+export interface ChatTurnRequestPayload {
     threadId: string;
     content?: string;
     /** Non-text parts from the upload route, echoed back verbatim. */
@@ -148,32 +147,32 @@ interface ChatTurnRequestPayload {
 /** `fetch` init for the turn route — the one place the client wire shape is
  *  serialized, so composer glue and products never drift from the server's
  *  parser. */
-declare function chatTurnRequestInit(payload: ChatTurnRequestPayload): RequestInit;
+export declare function chatTurnRequestInit(payload: ChatTurnRequestPayload): RequestInit;
 /** Define the maximum byte size allowed for inline parts in data processing */
-declare const INLINE_PARTS_MAX_BYTES = 950000;
+export declare const INLINE_PARTS_MAX_BYTES = 950000;
 /** Hard cap on the whole `/prompt` request body as it crosses the sandbox
  *  proxy — smaller in practice than a raw-file write cap because a dispatch
  *  carries several inline parts plus the flattened history in one request. */
-declare const DISPATCH_REQUEST_MAX_BYTES: number;
+export declare const DISPATCH_REQUEST_MAX_BYTES: number;
 /** Bytes reserved off the top of {@link DISPATCH_REQUEST_MAX_BYTES} for the
  *  JSON structure around the parts array (keys, delimiters, per-part
  *  `type`/`filename`/`mediaType` fields) that {@link base64WireLen} does not
  *  account for — keeps the inline budget off the exact proxy cap where one
  *  stray byte trips the 413. */
-declare const DISPATCH_STRUCTURAL_RESERVE_BYTES: number;
+export declare const DISPATCH_STRUCTURAL_RESERVE_BYTES: number;
 /** Sidecar's hard cap on the `parts` array of one prompt request — a dispatch
  *  must never assemble more parts than this or the whole turn 400s. */
-declare const DISPATCH_MAX_PARTS = 64;
+export declare const DISPATCH_MAX_PARTS = 64;
 /** Product-side cap on media parts per dispatch (current turn + carried
  *  history), well under {@link DISPATCH_MAX_PARTS}. History trimming that keeps
  *  a transcript's native media under this is a PRODUCT concern (the pointer
  *  block keeps trimmed media reachable); `buildDispatchParts` enforces only the
  *  total {@link DISPATCH_MAX_PARTS} cap. */
-declare const DISPATCH_MAX_MEDIA_PARTS = 24;
+export declare const DISPATCH_MAX_MEDIA_PARTS = 24;
 /** Size a base64-encoded string occupies on the wire given the raw
  *  (pre-encoding) byte length: base64 packs 3 raw bytes into 4 output
  *  characters, rounded up to the next multiple of 4. */
-declare function base64WireLen(byteLen: number): number;
+export declare function base64WireLen(byteLen: number): number;
 /**
  * Render a raw byte count as a human-readable size (`512B`, `3KB`, `12MB
  * 500KB`). Ported EXACTLY from gtm-agent's `attachment-limits.ts` — byte-
@@ -185,42 +184,42 @@ declare function base64WireLen(byteLen: number): number;
  * formatting for a client-side pre-check can also import it with no engine
  * pulled in.
  */
-declare function formatBytes(bytes: number): string;
+export declare function formatBytes(bytes: number): string;
 /** Represent errors for invalid chat turn inputs with status and code properties */
-declare class ChatTurnInputError extends Error {
+export declare class ChatTurnInputError extends Error {
     readonly status: number;
     readonly code: string;
     constructor(message: string, status?: number, code?: string);
 }
 /** Calculate the total byte size of an array of chat turn parts */
-declare function promptPartsByteSize(parts: ChatTurnPartInput[]): number;
+export declare function promptPartsByteSize(parts: ChatTurnPartInput[]): number;
 /** Throws `ChatTurnInputError` (413) when the parts' inline payload would blow
  *  the gateway cap. Path-ref parts are tiny by construction and always pass. */
-declare function assertPromptPartsWithinCap(parts: ChatTurnPartInput[], maxBytes?: number): void;
+export declare function assertPromptPartsWithinCap(parts: ChatTurnPartInput[], maxBytes?: number): void;
 /** A file mention resolved from the composer's `@`-picker: the
  *  workspace-relative path plus enough metadata to build a prompt part and
  *  pointer text. `path` is the canonical identity — the mention pill's
  *  `MentionItem.id` for the file kind (`/web-react`'s `useFileMentions`). */
-interface FileMention {
+export interface FileMention {
     path: string;
     name: string;
     size?: number;
 }
 /** The `image/*` mime for a mention path by extension, or `undefined` for
  *  anything not in the known image set (dispatched as `type: 'file'`). */
-declare function mediaTypeForMentionPath(path: string): string | undefined;
+export declare function mediaTypeForMentionPath(path: string): string | undefined;
 /** The image/file split a mention is rendered and persisted under — the
  *  composer pill's icon, the dispatched part's `type`, and
  *  `ChatMentionPart.mentionKind` are all this one value. */
-type ChatMentionKind = 'image' | 'file';
+export type ChatMentionKind = 'image' | 'file';
 /** `image` when the path's extension is in the known image set (the same table
  *  {@link mediaTypeForMentionPath} reads), `file` otherwise. Exported so a
  *  client that needs only the discriminant — a pill icon, a persisted part's
  *  `mentionKind` — never re-declares the extension table; two frozen copies of
  *  one mime table is how one gains a format and the other doesn't. */
-declare function mentionKindForPath(path: string): ChatMentionKind;
+export declare function mentionKindForPath(path: string): ChatMentionKind;
 /** Define options to resolve mention paths when converting file mentions to parts */
-interface FileMentionsToPartsOptions {
+export interface FileMentionsToPartsOptions {
     /** Resolve a mention's workspace-relative path to the absolute path the
      *  dispatched part should carry (e.g. a host prefixing the in-box vault
      *  root). Default: identity — the path travels unchanged. */
@@ -230,18 +229,18 @@ interface FileMentionsToPartsOptions {
  *  `image` vs `file` by extension, and always a `path`, never a `url` (the
  *  url/path XOR invariant: a mention is a sandbox path reference, never
  *  inline bytes). */
-declare function fileMentionsToParts(mentions: readonly FileMention[], opts?: FileMentionsToPartsOptions): ChatTurnFilePartInput[];
+export declare function fileMentionsToParts(mentions: readonly FileMention[], opts?: FileMentionsToPartsOptions): ChatTurnFilePartInput[];
 /** The agent-facing pointer block appended to the dispatched prompt — never
  *  persisted in message `content`. Empty array → `''` so callers can append
  *  unconditionally. This is the sole producer of that text: the current
  *  turn's dispatch and any history projection built from the same mention
  *  list both route through here, so the two can't drift apart. */
-declare function buildMentionPromptBlock(mentions: readonly Pick<FileMention, 'name' | 'path'>[]): string;
+export declare function buildMentionPromptBlock(mentions: readonly Pick<FileMention, 'name' | 'path'>[]): string;
 /** Hard cap on mentions per turn. Bounds the prompt pointer block, the
  *  persisted parts, and whatever media budget a dispatch draws from them. */
-declare const MENTION_MAX_COUNT = 16;
+export declare const MENTION_MAX_COUNT = 16;
 /** Represent the result of a sandbox mention path check indicating success or failure with an error message */
-type SandboxMentionPathCheck = {
+export type SandboxMentionPathCheck = {
     succeeded: true;
 } | {
     succeeded: false;
@@ -257,7 +256,7 @@ type SandboxMentionPathCheck = {
  * and an ASCII-only charset would silently drop real files from a feature
  * whose whole job is naming them.
  */
-declare function validateSandboxMentionPath(path: unknown): SandboxMentionPathCheck;
+export declare function validateSandboxMentionPath(path: unknown): SandboxMentionPathCheck;
 /**
  * Validates the untyped `mentions` array off the wire, mirroring
  * {@link parseChatTurnParts}: the typed list, or `ChatTurnInputError` (400)
@@ -268,9 +267,7 @@ declare function validateSandboxMentionPath(path: unknown): SandboxMentionPathCh
  * than rejected: mentioning the same file twice is plausible user input, not
  * an attack.
  */
-declare function parseFileMentions(raw: unknown): FileMention[];
+export declare function parseFileMentions(raw: unknown): FileMention[];
 /** Validates the untyped `parts` array off the wire. Returns the typed parts
  *  or throws `ChatTurnInputError` (400) naming the offending entry. */
-declare function parseChatTurnParts(raw: unknown): ChatTurnFilePartInput[];
-
-export { formatBytes as A, mediaTypeForMentionPath as B, type ChatMentionKind as C, DISPATCH_MAX_MEDIA_PARTS as D, mentionKindForPath as E, type FileMention as F, parseChatTurnParts as G, parseFileMentions as H, INLINE_PARTS_MAX_BYTES as I, promptPartsByteSize as J, validateSandboxMentionPath as K, MENTION_MAX_COUNT as M, type ProducerErrorEvent as P, type SandboxMentionPathCheck as S, type ChatAttachmentKind as a, type ChatAttachmentInput as b, type ChatTurnRequestPayload as c, type ChatTurnPartInput as d, type ChatTurnFilePartInput as e, type ChatReasoningEffort as f, ChatTurnInputError as g, type ChatTurnTextPartInput as h, DISPATCH_MAX_PARTS as i, DISPATCH_REQUEST_MAX_BYTES as j, DISPATCH_STRUCTURAL_RESERVE_BYTES as k, type FileMentionsToPartsOptions as l, type ProducerNoticeEvent as m, type ProducerPassthroughEvent as n, type ProducerPassthroughEventType as o, type ProducerReasoningEvent as p, type ProducerTextEvent as q, type ProducerToolCallEvent as r, type ProducerToolResultEvent as s, type ProducerUsageEvent as t, type ProducerWireEvent as u, assertPromptPartsWithinCap as v, base64WireLen as w, buildMentionPromptBlock as x, chatTurnRequestInit as y, fileMentionsToParts as z };
+export declare function parseChatTurnParts(raw: unknown): ChatTurnFilePartInput[];

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

@@ -0,0 +1,19 @@
+/**
+ * Pure (drizzle-free) pieces of the chat store: thread-title derivation, the
+ * bulk-delete bound, and the typed input error. Split from `./schema`/`./store`
+ * so the root barrel can re-export them without dragging the optional
+ * drizzle-orm peer into every root-entry consumer.
+ */
+/** Bounds a single bulk-delete request's write set; product surfaces cap
+ *  thread lists at far fewer, so a larger batch is a malformed or hostile
+ *  request. (Lifted from legal's api.threads.bulk-delete route.) */
+export declare const BULK_DELETE_MAX_THREADS = 200;
+/** Invalid caller input (missing/oversized ids, empty title). Products map it
+ *  to a 400; anything else out of the store is a real failure. */
+export declare class ChatStoreInputError extends Error {
+    constructor(message: string);
+}
+/** Thread titles come from the first message — keep the list scannable by
+ *  storing only its first non-empty line, capped at 80 chars, never the whole
+ *  multi-page prompt. (Lifted verbatim from legal's chat.new route.) */
+export declare function threadTitleFromMessage(message: string): string;

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

@@ -1,326 +1,26 @@
-import { C as ChatMessagePart } from '../parts-BqIHMdyu.js';
-export { a as ChatAttachmentPart, b as ChatFilePart, c as ChatImagePart, d as ChatInteractionPart, e as ChatMentionPart, f as ChatNoticePart, g as ChatPartTime, h as ChatPlanPart, i as ChatReasoningPart, j as ChatStepFinishPart, k as ChatStepStartPart, l as ChatSubtaskPart, m as ChatTextPart, n as ChatToolPart, o as ChatToolState, p as ChatToolStatus, q as ChatUsageTokens, r as ChatWorkProductPart, D as DEFAULT_ATTACHMENT_PROMPT_HEADER, S as StorableHarnessPartKind, s as attachmentInputToPart, t as attachmentKindForMime, u as attachmentPartsFromMessageParts, v as buildAttachmentPromptBlock, w as historyContentWithAttachments, x as isChatAttachmentPart, y as isChatInteractionPart, z as isChatMentionPart, A as isChatPlanPart, B as isChatStepFinishPart, E as isChatTextPart, F as isChatToolPart, G as isChatWorkProductPart, H as mentionInputToPart, I as mentionPartsFromMessageParts, J as toChatMessageParts } from '../parts-BqIHMdyu.js';
-import * as drizzle_orm from 'drizzle-orm';
-import { SQL } from 'drizzle-orm';
-import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
-import { AnySQLiteColumn, SQLiteTableExtraConfigValue, SQLiteColumnBuilderBase, AnySQLiteTable, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { SqliteBatchDatabase } from '../store/index.js';
-export { a as ChatAttachmentKind, C as ChatMentionKind } from '../wire-DOZ-O6hD.js';
-export { a as attachmentPartKey } from '../stream-normalizer-DKRxyVlZ.js';
-import '@tangle-network/agent-interface';
-import '../contract-OxG_jVMx.js';
-import '../types-CCeYywdS.js';
-import '../plans/index.js';
-
 /**
- * Pure (drizzle-free) pieces of the chat store: thread-title derivation, the
- * bulk-delete bound, and the typed input error. Split from `./schema`/`./store`
- * so the root barrel can re-export them without dragging the optional
- * drizzle-orm peer into every root-entry consumer.
- */
-/** Bounds a single bulk-delete request's write set; product surfaces cap
- *  thread lists at far fewer, so a larger batch is a malformed or hostile
- *  request. (Lifted from legal's api.threads.bulk-delete route.) */
-declare const BULK_DELETE_MAX_THREADS = 200;
-/** Invalid caller input (missing/oversized ids, empty title). Products map it
- *  to a 400; anything else out of the store is a real failure. */
-declare class ChatStoreInputError extends Error {
-    constructor(message: string);
-}
-/** Thread titles come from the first message — keep the list scannable by
- *  storing only its first non-empty line, capped at 80 chars, never the whole
- *  multi-page prompt. (Lifted verbatim from legal's chat.new route.) */
-declare function threadTitleFromMessage(message: string): string;
-
-/** A product table referenced by FK — only the `id` column is touched. */
-type ChatParentTable = AnySQLiteTable & {
-    id: AnySQLiteColumn;
-};
-/** Define options to customize chat thread and message table creation including workspace and naming prefixes */
-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.
+ * `/chat-store` — shared chat thread/message persistence (issue #188 Phase 1).
  *
- * 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.
- */
-type ChatExtraIndexes = (columns: Record<string, AnySQLiteColumn>) => SQLiteTableExtraConfigValue[];
-/** Build chat-related SQLite tables with customizable thread and message columns */
-declare function createChatTables<TThreadExtras extends Record<string, SQLiteColumnBuilderBase> = {}, TMessageExtras extends Record<string, SQLiteColumnBuilderBase> = {}>(options?: CreateChatTablesOptions<TThreadExtras, TMessageExtras>): {
-    threads: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: `${string}thread`;
-        schema: undefined;
-        columns: {
-            id: drizzle_orm.HasDefault<drizzle_orm.IsPrimaryKey<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>>;
-            workspaceId: drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"workspace_id", [string, ...string[]], number | undefined>>;
-            title: drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"title", [string, ...string[]], number | undefined>>;
-            category: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"category", [string, ...string[]], number | undefined>;
-            isPinned: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteBooleanBuilderInitial<"is_pinned">>>;
-            createdAt: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTimestampBuilderInitial<"created_at">>>;
-            updatedAt: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTimestampBuilderInitial<"updated_at">>>;
-        } & TThreadExtras extends infer T extends Record<string, drizzle_orm.ColumnBuilderBase<drizzle_orm.ColumnBuilderBaseConfig<drizzle_orm.ColumnDataType, string>, object>> ? { [Key in keyof T]: drizzle_orm.BuildColumn<TTableName, {
-            _: Omit<T[Key]["_"], "name"> & {
-                name: T[Key]["_"]["name"] extends "" ? drizzle_orm.Assume<Key, string> : T[Key]["_"]["name"];
-            };
-        }, TDialect>; } : never;
-        dialect: "sqlite";
-    }>;
-    messages: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
-        name: `${string}message`;
-        schema: undefined;
-        columns: {
-            id: drizzle_orm.HasDefault<drizzle_orm.IsPrimaryKey<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"id", [string, ...string[]], number | undefined>>>>;
-            threadId: drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"thread_id", [string, ...string[]], number | undefined>>;
-            role: drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"role", ["user", "assistant", "system", "tool"], number | undefined>>;
-            content: drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"content", [string, ...string[]], number | undefined>>;
-            parts: drizzle_orm.HasDefault<drizzle_orm.$Type<drizzle_orm_sqlite_core.SQLiteTextJsonBuilderInitial<"parts">, ChatMessagePart[]>>;
-            toolName: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"tool_name", [string, ...string[]], number | undefined>;
-            model: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"model", [string, ...string[]], number | undefined>;
-            requestedModel: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"requested_model", [string, ...string[]], number | undefined>;
-            servedModel: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"served_model", [string, ...string[]], number | undefined>;
-            servedProvider: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"served_provider", [string, ...string[]], number | undefined>;
-            servedSource: drizzle_orm_sqlite_core.SQLiteTextBuilderInitial<"served_model_source", [string, ...string[]], number | undefined>;
-            inputTokens: drizzle_orm_sqlite_core.SQLiteIntegerBuilderInitial<"input_tokens">;
-            outputTokens: drizzle_orm_sqlite_core.SQLiteIntegerBuilderInitial<"output_tokens">;
-            reasoningTokens: drizzle_orm_sqlite_core.SQLiteIntegerBuilderInitial<"reasoning_tokens">;
-            cacheReadTokens: drizzle_orm_sqlite_core.SQLiteIntegerBuilderInitial<"cache_read_tokens">;
-            cacheWriteTokens: drizzle_orm_sqlite_core.SQLiteIntegerBuilderInitial<"cache_write_tokens">;
-            costUsd: drizzle_orm_sqlite_core.SQLiteRealBuilderInitial<"cost_usd">;
-            createdAt: drizzle_orm.HasDefault<drizzle_orm.NotNull<drizzle_orm_sqlite_core.SQLiteTimestampBuilderInitial<"created_at">>>;
-        } & TMessageExtras extends infer T_1 extends Record<string, drizzle_orm.ColumnBuilderBase<drizzle_orm.ColumnBuilderBaseConfig<drizzle_orm.ColumnDataType, string>, object>> ? { [Key_1 in keyof T_1]: drizzle_orm.BuildColumn<TTableName, {
-            _: Omit<T_1[Key_1]["_"], "name"> & {
-                name: T_1[Key_1]["_"]["name"] extends "" ? 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.)
- */
-type ChatTables = ReturnType<typeof createChatTables<{}, {}>>;
-/** Resolve the selected fields of a chat thread row from the chat threads table */
-type ChatThreadRow = ChatTables['threads']['$inferSelect'];
-/** Resolve the selected structure of a chat message row from the messages table */
-type ChatMessageRow = ChatTables['messages']['$inferSelect'];
-/** Resolve the type for inserting a new chat thread row into the threads table */
-type NewChatThreadRow = ChatTables['threads']['$inferInsert'];
-/** Resolve the type for inserting a new chat message row into the messages table */
-type NewChatMessageRow = ChatTables['messages']['$inferInsert'];
-
-/**
- * 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).
+ * Unifies the three divergent product implementations (legal's `thread`/
+ * `message`, gtm's fix-absorbed copy of the same, tax's `tax_sessions`/
+ * `chat_messages`) into one drizzle table factory + typed CRUD store, so
+ * products stop hand-rolling incompatible chat schemas:
+ * - `createChatTables` (./schema) — the table factory; per-divergence
+ *   rationale lives in its docblock.
+ * - `createChatStore` (./store) — list/get/create/rename/pin/delete/bulk-
+ *   delete threads + list/append messages, with access control as an injected
+ *   callback seam.
+ * - `ChatMessagePart` (./parts) — the canonical stored `parts` vocabulary both
+ *   transport lanes (harness `message.part.updated`, router openai-compat)
+ *   serialize into; source citations in its docblock.
+ * - pure helpers (./core) — `threadTitleFromMessage`, `ChatStoreInputError`,
+ *   `BULK_DELETE_MAX_THREADS` (also re-exported from the root barrel).
  *
- * 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.
+ * Imports `drizzle-orm` at module top — that is WHY this lives behind its own
+ * subpath: the root barrel re-exports only `./core` + `./parts`, so a
+ * consumer that never touches the DB never pulls the optional peer.
  */
-
-/** 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. */
-type ChatDatabase = BaseSQLiteDatabase<'sync' | 'async', any, any> & SqliteBatchDatabase;
-/** Product-injected access check. Throw to deny; the store never interprets
- *  users or roles itself. */
-type WorkspaceAccessCheck = (workspaceId: string) => void | Promise<void>;
-/** Define input parameters for listing threads within a workspace with pagination options */
-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 */
-interface ListThreadsResult<TThread = ChatThreadRow> {
-    threads: TThread[];
-    total: number;
-    limit: number;
-    offset: number;
-}
-/** Define input parameters required to create a new thread in a workspace */
-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 */
-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. */
-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 */
-interface ListMessagesOptions {
-    limit?: number;
-    offset?: number;
-}
-/** Define input for bulk deleting threads with access checks per workspace */
-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. */
-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 */
-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 */
-declare function createChatStore<TTables extends ChatTables>(db: ChatDatabase, tables: TTables): ChatStore<TTables['threads']['$inferSelect'], TTables['messages']['$inferSelect']>;
-
-export { type AppendMessageInput, BULK_DELETE_MAX_THREADS, type BulkDeleteThreadsByUpdatedAtInput, type BulkDeleteThreadsInput, type ChatDatabase, type ChatExtraIndexes, ChatMessagePart, type ChatMessageRow, type ChatParentTable, type ChatStore, ChatStoreInputError, type ChatTables, type ChatThreadRow, type CreateChatTablesOptions, type CreateThreadInput, type ListMessagesOptions, type ListThreadsInput, type ListThreadsResult, type NewChatMessageRow, type NewChatThreadRow, type UpdateMessageInput, type WorkspaceAccessCheck, createChatStore, createChatTables, threadTitleFromMessage };
+export * from './core';
+export * from './parts';
+export * from './schema';
+export * from './store';