@happyvertical/smrt-app-shell 0.0.0-stage → 0.60.16

package/dist/lib/objects/App.d.ts

@@ -0,0 +1,60 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+import { type FieldDef, type MethodDef } from '../../engine/index.ts';
+import { type BuilderResult } from '../server/builder.ts';
+/**
+ * The shell's one app: a singleton row holding the current definition. Its
+ * static methods are the builder operations (so smrt generates their REST,
+ * MCP and CLI). All are owner only. A risky one does not apply: it returns
+ * `{ status: 'pending_approval', approvalId, summary, preview }` and waits for
+ * the owner's decision (`Approval.decide`).
+ */
+export declare class App extends SmrtObject {
+    /** Display name of the user app. */
+    name: string;
+    /** The current version number, `-1` before the first start. */
+    currentVersion: number;
+    /** The current definition, JSON text (a copy of the AppVersion row). */
+    definition: string;
+    /** Add a model with its fields. */
+    static defineModel(name: string, fields?: Record<string, FieldDef>, label?: string): Promise<BuilderResult>;
+    /** Add a field to a model. */
+    static addField(model: string, field: string, definition: FieldDef): Promise<BuilderResult>;
+    /** Hide a field (kept in the data, not shown). */
+    static hideField(model: string, field: string): Promise<BuilderResult>;
+    /** Rename a field; its values move with it. */
+    static renameField(model: string, from: string, to: string): Promise<BuilderResult>;
+    /** Remove a field (risky: needs the owner's approval; values are archived). */
+    static removeField(model: string, field: string): Promise<BuilderResult>;
+    /** Change a field's type (risky: needs the owner's approval). */
+    static changeFieldType(model: string, field: string, definition: FieldDef): Promise<BuilderResult>;
+    /** Remove a model (risky: needs the owner's approval; its table is moved aside). */
+    static removeModel(model: string): Promise<BuilderResult>;
+    /** Add a code method to a model (risky: needs the owner's approval). */
+    static addMethod(model: string, name: string, method: MethodDef): Promise<BuilderResult>;
+    /** Turn on a shipped recipe such as `profiles`. */
+    static enableRecipe(recipe: string): Promise<BuilderResult>;
+    /**
+     * Undo the last change. If that change converted a field's type, going back
+     * would overwrite newer values with the archived originals, so it waits for
+     * the owner's approval (`pending_approval`).
+     */
+    static undo(): Promise<BuilderResult>;
+    /** Purge old archives, keeping the last `keep` changes (risky). */
+    static cleanUp(keep?: number): Promise<BuilderResult>;
+    /** Export the definition (and optionally the records) as a template. */
+    static exportTemplate(includeRecords?: boolean): Promise<BuilderResult>;
+    /** Import a template, replacing the definition (risky if it has code). */
+    static importTemplate(data: Record<string, unknown>): Promise<BuilderResult>;
+    /** The models, fields and methods of the app now. */
+    static describe(): Promise<{
+        name: string;
+        version: number;
+        recipes: string[];
+        models: Record<string, import("../../engine/definition.ts").DescribedModel>;
+    }>;
+    /** Every version of the app, newest last. */
+    static history(): Promise<import("../../engine/host.ts").VersionSummary[]>;
+}
+export declare class AppCollection extends SmrtCollection<App> {
+    static readonly _itemClass: typeof App;
+}

package/dist/lib/objects/App.js

@@ -0,0 +1,273 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+import { EngineError, } from "../../engine/index.js";
+import { runCommand } from "../server/builder.js";
+import { getHost } from "../server/host.js";
+import { assertOwner } from "../server/owner.js";
+// The decorator config must be a literal: the smrt() scanner reads it
+// statically (a shared constant would be invisible to it and every generated
+// surface would default to full CRUD). The collection repeats it exactly:
+// core applies a collection's @smrt() config to its item class.
+//
+// `operationPermissions` maps each custom operation onto the collection's own
+// CRUD grant; the owner-only rule itself is `assertOwner()` inside every
+// method (defense in depth: the generated routes also check the grant, but a
+// member role may hold it).
+/**
+ * A JSON object argument that may arrive as a JSON string (MCP clients). A
+ * wrong shape is a 400 that says what to send, never a server error.
+ */
+function obj(value, what, example = '{...}') {
+    let v = value;
+    if (typeof v === 'string') {
+        try {
+            v = JSON.parse(v);
+        }
+        catch {
+            throw new EngineError(`${what} must be an object like ${example}`, 'invalid');
+        }
+    }
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new EngineError(`${what} must be an object like ${example}`, 'invalid');
+    return v;
+}
+function str(value, what) {
+    if (typeof value !== 'string' || !value)
+        throw new EngineError(`${what} must be a non-empty string`, 'invalid');
+    return value;
+}
+const FIELD_EXAMPLE = "{type: 'integer'}";
+async function run(command) {
+    const owner = await assertOwner();
+    return runCommand(command, owner.id);
+}
+/**
+ * The shell's one app: a singleton row holding the current definition. Its
+ * static methods are the builder operations (so smrt generates their REST,
+ * MCP and CLI). All are owner only. A risky one does not apply: it returns
+ * `{ status: 'pending_approval', approvalId, summary, preview }` and waits for
+ * the owner's decision (`Approval.decide`).
+ */
+let App = class App extends SmrtObject {
+    /** Display name of the user app. */
+    name = 'My app';
+    /** The current version number, `-1` before the first start. */
+    currentVersion = -1;
+    /** The current definition, JSON text (a copy of the AppVersion row). */
+    definition = '';
+    /** Add a model with its fields. */
+    static async defineModel(name, fields, label) {
+        // The shell's own tools are `app_*` and `approval_*`; an app model with
+        // either name would generate colliding tool names.
+        if (/^(app|approval)$/i.test(String(name)))
+            throw new Error(`"${name}" is reserved for the shell`);
+        return run({
+            type: 'defineModel',
+            name: str(name, 'name'),
+            ...(label ? { label: str(label, 'label') } : {}),
+            ...(fields === undefined
+                ? {}
+                : {
+                    fields: obj(fields, 'fields', "{title: {type: 'text'}}"),
+                }),
+        });
+    }
+    /** Add a field to a model. */
+    static async addField(model, field, definition) {
+        return run({
+            type: 'addField',
+            model: str(model, 'model'),
+            field: str(field, 'field'),
+            definition: obj(definition, 'definition', FIELD_EXAMPLE),
+        });
+    }
+    /** Hide a field (kept in the data, not shown). */
+    static async hideField(model, field) {
+        return run({
+            type: 'hideField',
+            model: str(model, 'model'),
+            field: str(field, 'field'),
+        });
+    }
+    /** Rename a field; its values move with it. */
+    static async renameField(model, from, to) {
+        return run({
+            type: 'renameField',
+            model: str(model, 'model'),
+            from: str(from, 'from'),
+            to: str(to, 'to'),
+        });
+    }
+    /** Remove a field (risky: needs the owner's approval; values are archived). */
+    static async removeField(model, field) {
+        return run({
+            type: 'removeField',
+            model: str(model, 'model'),
+            field: str(field, 'field'),
+        });
+    }
+    /** Change a field's type (risky: needs the owner's approval). */
+    static async changeFieldType(model, field, definition) {
+        return run({
+            type: 'changeFieldType',
+            model: str(model, 'model'),
+            field: str(field, 'field'),
+            to: obj(definition, 'definition', FIELD_EXAMPLE),
+        });
+    }
+    /** Remove a model (risky: needs the owner's approval; its table is moved aside). */
+    static async removeModel(model) {
+        return run({ type: 'removeModel', model: str(model, 'model') });
+    }
+    /** Add a code method to a model (risky: needs the owner's approval). */
+    static async addMethod(model, name, method) {
+        return run({
+            type: 'addMethod',
+            model: str(model, 'model'),
+            name: str(name, 'name'),
+            method: obj(method, 'method', "{description: '...', code: 'return 1;'}"),
+        });
+    }
+    /** Turn on a shipped recipe such as `profiles`. */
+    static async enableRecipe(recipe) {
+        return run({ type: 'enableRecipe', recipe: str(recipe, 'recipe') });
+    }
+    /**
+     * Undo the last change. If that change converted a field's type, going back
+     * would overwrite newer values with the archived originals, so it waits for
+     * the owner's approval (`pending_approval`).
+     */
+    static async undo() {
+        return run({ type: 'undo' });
+    }
+    /** Purge old archives, keeping the last `keep` changes (risky). */
+    static async cleanUp(keep) {
+        const n = keep === undefined ? 5 : Number(keep);
+        if (!Number.isInteger(n) || n < 0)
+            throw new Error('keep must be a whole number, zero or more');
+        return run({ type: 'cleanUp', keep: n });
+    }
+    /** Export the definition (and optionally the records) as a template. */
+    static async exportTemplate(includeRecords) {
+        return run({
+            type: 'exportTemplate',
+            includeRecords: includeRecords === true,
+        });
+    }
+    /** Import a template, replacing the definition (risky if it has code). */
+    static async importTemplate(data) {
+        return run({
+            type: 'importTemplate',
+            data: obj(data, 'data', '{format: 1, definition: {...}}'),
+        });
+    }
+    /** The models, fields and methods of the app now. */
+    static async describe() {
+        await assertOwner();
+        return (await getHost()).describe();
+    }
+    /** Every version of the app, newest last. */
+    static async history() {
+        await assertOwner();
+        return (await getHost()).versions();
+    }
+};
+__decorate([
+    field({ type: 'text' })
+], App.prototype, "name", void 0);
+__decorate([
+    field({ type: 'integer' })
+], App.prototype, "currentVersion", void 0);
+__decorate([
+    field({ type: 'text' })
+], App.prototype, "definition", void 0);
+App = __decorate([
+    smrt({
+        tableName: 'apps',
+        conflictColumns: ['id'],
+        api: {
+            include: [
+                'defineModel',
+                'addField',
+                'hideField',
+                'renameField',
+                'removeField',
+                'changeFieldType',
+                'removeModel',
+                'addMethod',
+                'enableRecipe',
+                'undo',
+                'cleanUp',
+                'exportTemplate',
+                'importTemplate',
+                'describe',
+                'history',
+            ],
+        },
+        mcp: {
+            include: [
+                'defineModel',
+                'addField',
+                'hideField',
+                'renameField',
+                'removeField',
+                'changeFieldType',
+                'removeModel',
+                'addMethod',
+                'enableRecipe',
+                'undo',
+                'cleanUp',
+                'exportTemplate',
+                'importTemplate',
+                'describe',
+                'history',
+            ],
+        },
+        cli: {
+            include: [
+                'defineModel',
+                'addField',
+                'hideField',
+                'renameField',
+                'removeField',
+                'changeFieldType',
+                'removeModel',
+                'addMethod',
+                'enableRecipe',
+                'undo',
+                'cleanUp',
+                'exportTemplate',
+                'importTemplate',
+                'describe',
+                'history',
+            ],
+        },
+        operationPermissions: {
+            defineModel: { action: 'update' },
+            addField: { action: 'update' },
+            hideField: { action: 'update' },
+            renameField: { action: 'update' },
+            removeField: { action: 'update' },
+            changeFieldType: { action: 'update' },
+            removeModel: { action: 'update' },
+            addMethod: { action: 'update' },
+            enableRecipe: { action: 'update' },
+            undo: { action: 'update' },
+            cleanUp: { action: 'update' },
+            exportTemplate: { action: 'read' },
+            importTemplate: { action: 'update' },
+            describe: { action: 'read' },
+            history: { action: 'read' },
+        },
+    })
+], App);
+export { App };
+// Undecorated on purpose: the item class carries the whole generated surface.
+export class AppCollection extends SmrtCollection {
+    static _itemClass = App;
+}

package/dist/lib/objects/AppVersion.d.ts

@@ -0,0 +1,22 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+/**
+ * One version of the user app's definition (shell.db). Never deleted: an old
+ * version's migration is marked `purged` once its archives are cleaned up.
+ * Written only by `ShellVersionStore`; no generated surface.
+ */
+export declare class AppVersion extends SmrtObject {
+    version: number;
+    /** Parent version, `-1` for none (the first version). */
+    parent: number;
+    author: string;
+    summary: string;
+    /** The whole definition, JSON text. */
+    definition: string;
+    /** `{ steps, purged? }` JSON text, or empty for a change with no migration. */
+    migration: string;
+    createdAt: string;
+    purged: boolean;
+}
+export declare class AppVersionCollection extends SmrtCollection<AppVersion> {
+    static readonly _itemClass: typeof AppVersion;
+}

package/dist/lib/objects/AppVersion.js

@@ -0,0 +1,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+/**
+ * One version of the user app's definition (shell.db). Never deleted: an old
+ * version's migration is marked `purged` once its archives are cleaned up.
+ * Written only by `ShellVersionStore`; no generated surface.
+ */
+let AppVersion = class AppVersion extends SmrtObject {
+    version = 0;
+    /** Parent version, `-1` for none (the first version). */
+    parent = -1;
+    author = '';
+    summary = '';
+    /** The whole definition, JSON text. */
+    definition = '';
+    /** `{ steps, purged? }` JSON text, or empty for a change with no migration. */
+    migration = '';
+    createdAt = '';
+    purged = false;
+};
+__decorate([
+    field({ type: 'integer', required: true })
+], AppVersion.prototype, "version", void 0);
+__decorate([
+    field({ type: 'integer' })
+], AppVersion.prototype, "parent", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppVersion.prototype, "author", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppVersion.prototype, "summary", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppVersion.prototype, "definition", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppVersion.prototype, "migration", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppVersion.prototype, "createdAt", void 0);
+__decorate([
+    field({ type: 'boolean' })
+], AppVersion.prototype, "purged", void 0);
+AppVersion = __decorate([
+    smrt({
+        tableName: 'app_versions',
+        api: false,
+        mcp: false,
+        cli: false,
+        conflictColumns: ['id'],
+    })
+], AppVersion);
+export { AppVersion };
+export class AppVersionCollection extends SmrtCollection {
+    static _itemClass = AppVersion;
+}

package/dist/lib/objects/Approval.d.ts

@@ -0,0 +1,39 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+import { type ApprovalOutcome } from '../server/approvals.ts';
+export type ApprovalStatus = 'pending' | 'approved' | 'denied' | 'failed';
+/**
+ * A risky change waiting for the owner. Created by the shell when a risky
+ * builder method, app tool or REST DELETE is attempted; applied only by
+ * {@link Approval.decide} (the one place the engine's `approved` flag is set).
+ */
+export declare class Approval extends SmrtObject {
+    /** The action to run on approval, JSON (`ApprovalAction`). */
+    command: string;
+    /** Stable hash of the action; one pending row per identical action. */
+    actionKey: string;
+    summary: string;
+    /** What the change would do (counts, affected methods), JSON. */
+    preview: string;
+    status: ApprovalStatus;
+    requestedBy: string;
+    decidedBy: string;
+    decidedAt: string;
+    /** The result of applying it, or the failure, JSON. */
+    result: string;
+    createdAt: string;
+    /**
+     * Approve (apply the change) or deny it. Owner only. Approving a change
+     * that fails records the failure and leaves nothing half-applied.
+     */
+    decide(approve: boolean): Promise<ApprovalOutcome>;
+    /** The approvals waiting for the owner. */
+    static pending(): Promise<import("../server/approvals.ts").ApprovalView[]>;
+}
+/**
+ * Undecorated on purpose: the item class carries the whole surface (core
+ * applies the collection's config to the item class, so a decorated
+ * collection would have to repeat it exactly).
+ */
+export declare class ApprovalCollection extends SmrtCollection<Approval> {
+    static readonly _itemClass: typeof Approval;
+}

package/dist/lib/objects/Approval.js

@@ -0,0 +1,101 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+import { decideApproval, listApprovalViews, } from "../server/approvals.js";
+import { assertOwner } from "../server/owner.js";
+// The decorator config must be a literal (the smrt() scanner reads it
+// statically) and is repeated on the collection (core applies a collection's
+// @smrt() config to its item class).
+/**
+ * A risky change waiting for the owner. Created by the shell when a risky
+ * builder method, app tool or REST DELETE is attempted; applied only by
+ * {@link Approval.decide} (the one place the engine's `approved` flag is set).
+ */
+let Approval = class Approval extends SmrtObject {
+    /** The action to run on approval, JSON (`ApprovalAction`). */
+    command = '';
+    /** Stable hash of the action; one pending row per identical action. */
+    actionKey = '';
+    summary = '';
+    /** What the change would do (counts, affected methods), JSON. */
+    preview = '';
+    status = 'pending';
+    requestedBy = '';
+    decidedBy = '';
+    decidedAt = '';
+    /** The result of applying it, or the failure, JSON. */
+    result = '';
+    createdAt = '';
+    /**
+     * Approve (apply the change) or deny it. Owner only. Approving a change
+     * that fails records the failure and leaves nothing half-applied.
+     */
+    async decide(approve) {
+        const owner = await assertOwner();
+        return decideApproval(this.id, approve === true, owner.id);
+    }
+    /** The approvals waiting for the owner. */
+    static async pending() {
+        await assertOwner();
+        return listApprovalViews({ status: 'pending' });
+    }
+};
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "command", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "actionKey", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "summary", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "preview", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "status", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "requestedBy", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "decidedBy", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "decidedAt", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "result", void 0);
+__decorate([
+    field({ type: 'text' })
+], Approval.prototype, "createdAt", void 0);
+Approval = __decorate([
+    smrt({
+        tableName: 'approvals',
+        conflictColumns: ['id'],
+        // Only the owner decides. The generated list/get/create/update/delete are
+        // not exposed: the owner reads approvals through `pending` and
+        // /api/shell/approvals, and rows are written only by the approval service.
+        api: { include: ['decide', 'pending'] },
+        mcp: { include: ['decide', 'pending'] },
+        cli: false,
+        operationPermissions: {
+            decide: { action: 'update' },
+            pending: { action: 'read' },
+        },
+    })
+], Approval);
+export { Approval };
+/**
+ * Undecorated on purpose: the item class carries the whole surface (core
+ * applies the collection's config to the item class, so a decorated
+ * collection would have to repeat it exactly).
+ */
+export class ApprovalCollection extends SmrtCollection {
+    static _itemClass = Approval;
+}

package/dist/lib/objects/AssistantMessage.d.ts

@@ -0,0 +1,24 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+export type AssistantRole = 'user' | 'assistant' | 'tool';
+/**
+ * One message of an assistant thread (shell.db): the owner's text, the
+ * model's reply (with the tool calls it asked for) or a tool result. Written
+ * only by the assistant's thread store; no generated surface.
+ */
+export declare class AssistantMessage extends SmrtObject {
+    threadId: string;
+    /** Order within the thread, from 1. */
+    seq: number;
+    role: AssistantRole;
+    content: string;
+    /** Assistant messages: the tool calls the model asked for, JSON. */
+    toolCalls: string;
+    /** Tool messages: the call this answers. */
+    toolCallId: string;
+    /** Tool messages: `{ name, ok, summary, approvalId? }` JSON for the chips. */
+    meta: string;
+    createdAt: string;
+}
+export declare class AssistantMessageCollection extends SmrtCollection<AssistantMessage> {
+    static readonly _itemClass: typeof AssistantMessage;
+}

package/dist/lib/objects/AssistantMessage.js

@@ -0,0 +1,63 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+/**
+ * One message of an assistant thread (shell.db): the owner's text, the
+ * model's reply (with the tool calls it asked for) or a tool result. Written
+ * only by the assistant's thread store; no generated surface.
+ */
+let AssistantMessage = class AssistantMessage extends SmrtObject {
+    threadId = '';
+    /** Order within the thread, from 1. */
+    seq = 0;
+    role = 'user';
+    content = '';
+    /** Assistant messages: the tool calls the model asked for, JSON. */
+    toolCalls = '';
+    /** Tool messages: the call this answers. */
+    toolCallId = '';
+    /** Tool messages: `{ name, ok, summary, approvalId? }` JSON for the chips. */
+    meta = '';
+    createdAt = '';
+};
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "threadId", void 0);
+__decorate([
+    field({ type: 'integer' })
+], AssistantMessage.prototype, "seq", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "role", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "content", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "toolCalls", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "toolCallId", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "meta", void 0);
+__decorate([
+    field({ type: 'text' })
+], AssistantMessage.prototype, "createdAt", void 0);
+AssistantMessage = __decorate([
+    smrt({
+        tableName: 'assistant_messages',
+        api: false,
+        mcp: false,
+        cli: false,
+        conflictColumns: ['id'],
+    })
+], AssistantMessage);
+export { AssistantMessage };
+export class AssistantMessageCollection extends SmrtCollection {
+    static _itemClass = AssistantMessage;
+}

package/dist/lib/objects/AssistantThread.d.ts

@@ -0,0 +1,16 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+/**
+ * One assistant conversation (shell.db). Written only by the assistant's
+ * thread store (`$lib/server/assistant/threads`), owner scoped; no generated
+ * surface.
+ */
+export declare class AssistantThread extends SmrtObject {
+    /** The owner's user id. */
+    ownerId: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class AssistantThreadCollection extends SmrtCollection<AssistantThread> {
+    static readonly _itemClass: typeof AssistantThread;
+}