@peers-app/peers-sdk 0.25.21 → 0.26.0

package/dist/contracts/tool-catalog.js

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCatalog = void 0;
+exports.toolCatalogTarget = toolCatalogTarget;
+exports.retainToolCatalogFields = retainToolCatalogFields;
+exports.validateToolCatalogWrite = validateToolCatalogWrite;
+const lodash_1 = require("lodash");
+const tools_1 = require("../data/tools");
+const system_contracts_1 = require("./system-contracts");
+const tool_catalog_identity_1 = require("./tool-catalog-identity");
+const tool_catalog_migrations_1 = require("./tool-catalog-migrations");
+/** Read a complete canonical target; partial mappings are invalid, not legacy tools. */
+function toolCatalogTarget(row) {
+    if (row.contractId === undefined &&
+        row.contractVersion === undefined &&
+        row.toolName === undefined)
+        return undefined;
+    if (row.contractId === undefined ||
+        row.contractVersion === undefined ||
+        row.toolName === undefined)
+        throw new Error("Incomplete tool catalog target");
+    const target = {
+        contractId: row.contractId,
+        version: row.contractVersion,
+        toolName: row.toolName,
+    };
+    (0, tool_catalog_identity_1.validateToolCatalogTarget)(target);
+    return target;
+}
+/**
+ * Mixed-version sync: runtimes that predate the catalog columns reconstruct and write
+ * full rows without them. When a synced candidate carries none of the catalog-owned
+ * fields, keep the established row's identity and state rather than rejecting the
+ * write as a retarget. A candidate carrying any catalog field is returned unchanged
+ * and validated as written, so partial stripping and retargeting still fail.
+ *
+ * @param existing - Materialized row, if any.
+ * @param candidate - Reconstructed row about to replace it.
+ * @returns The row to validate and write.
+ */
+function retainToolCatalogFields(existing, candidate) {
+    if (!existing || tools_1.toolCatalogIdentityFields.some((field) => candidate[field] !== undefined))
+        return candidate;
+    const retained = { ...candidate };
+    for (const field of tools_1.toolCatalogIdentityFields) {
+        if (existing[field] !== undefined)
+            Object.assign(retained, { [field]: existing[field] });
+    }
+    return retained;
+}
+/** Reviewed aliases and deterministic IDs are catalog identities even before their rows exist. */
+function isReservedToolCatalogId(toolId) {
+    return ((0, tool_catalog_migrations_1.resolveLegacyToolId)(toolId) !== undefined ||
+        ((0, tool_catalog_identity_1.isCatalogToolId)(toolId) && toolId.startsWith("000tool0")));
+}
+/** Whether a stored row carries catalog identity or quarantine evidence. */
+function hasToolCatalogEvidence(row) {
+    return (row.catalogState === "resolved" ||
+        row.catalogState === "quarantined" ||
+        row.catalogIdentity !== undefined ||
+        row.contractId !== undefined ||
+        row.contractVersion !== undefined ||
+        row.toolName !== undefined);
+}
+/**
+ * Shared pre-persistence identity guard for local writes and reconstructed sync rows.
+ * Existing mappings cannot be retargeted, stripped or deleted. Rejected sync evidence
+ * belongs in the sync recovery queue; it must not replace the established row.
+ * Pass recordId for deletes so reserved identities are protected before materialization.
+ *
+ * Catalog identities are permanent. Unresolved legacy rows are a holdover until their
+ * tools move to contracts: they stay ordinary rows that local writers and older
+ * runtimes may delete.
+ */
+function validateToolCatalogWrite(existing, candidate, recordId = candidate?.toolId ?? existing?.toolId) {
+    if (!candidate) {
+        if ((recordId !== undefined && isReservedToolCatalogId(recordId)) ||
+            (existing && hasToolCatalogEvidence(existing)))
+            throw new Error("Tools catalog rows are permanent");
+        return;
+    }
+    if (!candidate.toolId ||
+        !(0, tool_catalog_identity_1.isCatalogToolId)(candidate.toolId) ||
+        (existing && existing.toolId !== candidate.toolId))
+        throw new Error("Tool catalog primary key mismatch");
+    if (existing?.catalogState === "quarantined" && candidate.catalogState !== "quarantined")
+        throw new Error(`Quarantined tool identity: ${candidate.toolId}`);
+    // Quarantine preserves the original evidence byte-for-byte; it cannot retarget it.
+    if (existing &&
+        candidate.catalogState === "quarantined" &&
+        existing.contractId === candidate.contractId &&
+        existing.contractVersion === candidate.contractVersion &&
+        existing.toolName === candidate.toolName &&
+        existing.catalogIdentity === candidate.catalogIdentity)
+        return;
+    const target = toolCatalogTarget(candidate);
+    const legacy = (0, tool_catalog_migrations_1.resolveLegacyToolId)(candidate.toolId);
+    const previous = existing && toolCatalogTarget(existing);
+    if (previous && (!target || (0, tool_catalog_identity_1.toolCatalogTargetKey)(previous) !== (0, tool_catalog_identity_1.toolCatalogTargetKey)(target)))
+        throw new Error(`Tool catalog identity cannot change: ${candidate.toolId}`);
+    if (target) {
+        if (existing && !previous && !legacy)
+            throw new Error(`Unresolved tool identity cannot be claimed: ${candidate.toolId}`);
+        if (!(0, tool_catalog_migrations_1.toolCatalogIds)(target).includes(candidate.toolId))
+            throw new Error(`Unknown tool catalog mapping: ${candidate.toolId}`);
+        if (legacy && (0, tool_catalog_identity_1.toolCatalogTargetKey)(legacy) !== (0, tool_catalog_identity_1.toolCatalogTargetKey)(target))
+            throw new Error(`Conflicting legacy tool mapping: ${candidate.toolId}`);
+        const identity = legacy ? "legacy-alias" : "deterministic";
+        if (candidate.catalogIdentity !== undefined && candidate.catalogIdentity !== identity)
+            throw new Error(`Incorrect catalog identity kind: ${candidate.toolId}`);
+    }
+    else if (candidate.catalogState === "resolved" ||
+        candidate.catalogIdentity ||
+        candidate.toolId.startsWith("000tool0")) {
+        throw new Error(`Missing tool catalog target: ${candidate.toolId}`);
+    }
+}
+/** JSON-equivalent comparison: key order and undefined members are not changes. */
+function sameValue(a, b) {
+    const normalize = (value) => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+    return (0, lodash_1.isEqual)(normalize(a), normalize(b));
+}
+function resolvedFields(target, toolId) {
+    return {
+        contractId: target.contractId,
+        contractVersion: target.version,
+        toolName: target.toolName,
+        catalogIdentity: (0, tool_catalog_migrations_1.resolveLegacyToolId)(toolId) ? "legacy-alias" : "deterministic",
+        catalogState: "resolved",
+        catalogReason: undefined,
+    };
+}
+/**
+ * Per-context runtime owner of permanent Tools identities. Construction is inert;
+ * ready() explicitly initializes storage after UserContext construction completes.
+ * No worker, resolver or executable ToolInstance is needed to index public members.
+ */
+class ToolCatalog {
+    dataContext;
+    registry;
+    tail = Promise.resolve();
+    initialization;
+    subscription;
+    disposed = false;
+    reconciliationQueued = false;
+    /** Bind to the registry shared by host and isolated providers in this context. */
+    constructor(dataContext, registry) {
+        this.dataContext = dataContext;
+        this.registry = registry;
+        if (registry.toolCatalog)
+            throw new Error("Registry already owns a tool catalog");
+        registry.toolCatalog = this;
+    }
+    enqueue(work) {
+        const result = this.tail.then(() => {
+            if (this.disposed)
+                throw new Error("Tool catalog disposed");
+            return work();
+        });
+        this.tail = result.catch(() => undefined);
+        return result;
+    }
+    /** Await successful backfill and system publication. Failed initialization can be retried. */
+    ready() {
+        if (this.disposed)
+            return Promise.reject(new Error("Tool catalog disposed"));
+        if (!this.initialization) {
+            this.initialization = this.enqueue(async () => {
+                await this.reconcile();
+                const groups = new Map();
+                for (const entry of (0, system_contracts_1.listSystemContracts)()) {
+                    const entries = groups.get(entry.providerPackageId) ?? [];
+                    entries.push({ definition: entry.getDefinition() });
+                    groups.set(entry.providerPackageId, entries);
+                }
+                for (const [provider, registrations] of groups) {
+                    this.validate(provider, registrations);
+                }
+                // System upgrades refresh contract-owned descriptions on every start.
+                for (const [provider, registrations] of groups)
+                    await this.materialize(registrations, true, provider);
+                // Guard the complete system snapshot before publishing any provider.
+                // A later save/read may have invalidated an earlier provider's row.
+                await this.guardActivation(groups, () => {
+                    this.assertLive();
+                    for (const [provider, registrations] of groups) {
+                        this.registry.replaceBatch(provider, registrations);
+                    }
+                });
+                // dispose() may have run while initialization awaited storage; it has
+                // already unsubscribed, so a late subscription would never be released.
+                this.assertLive();
+                this.subscription ??= (0, tools_1.Tools)(this.dataContext).dataChanged.subscribe(() => {
+                    if (this.reconciliationQueued || this.disposed)
+                        return;
+                    this.reconciliationQueued = true;
+                    void this.enqueue(async () => {
+                        this.reconciliationQueued = false;
+                        await this.reconcile();
+                    }).catch((error) => console.error("Tool catalog reconciliation failed", error));
+                });
+            }).catch((error) => {
+                this.initialization = undefined;
+                throw error;
+            });
+        }
+        return this.initialization;
+    }
+    assertLive() {
+        if (this.disposed)
+            throw new Error("Tool catalog disposed");
+    }
+    validate(provider, registrations) {
+        this.assertLive();
+        const result = this.registry.validateBatch(provider, registrations);
+        if (!result.valid)
+            throw new Error(`Contract registration failed: ${result.errors.map((e) => e.message).join("; ")}`);
+    }
+    /**
+     * Serialize validation, catalog persistence, package preparation and activation.
+     * A failed preparation never publishes the candidate or changes live tool policy.
+     * Successful catalog additions remain historical even if later preparation fails.
+     * Descriptive metadata of existing rows is refreshed only after preparation
+     * succeeds, so a failed replacement leaves the active provider's rows unchanged.
+     * Async activation must call the supplied guard in its final synchronous commit
+     * turn, before publishing providers or changing live bindings. The guard observes
+     * catalog changes immediately, independently of queued reconciliation.
+     */
+    async publish(provider, registrations, prepare, activate, toolMetadata = []) {
+        if (toolMetadata.length) {
+            const members = new Set(this.definitions(registrations).flatMap((definition) => definition.tools.map((tool) => (0, tool_catalog_identity_1.toolCatalogTargetKey)({
+                contractId: definition.contractId,
+                version: definition.version,
+                toolName: tool.name,
+            }))));
+            for (const metadata of toolMetadata) {
+                (0, tool_catalog_identity_1.validateToolCatalogTarget)(metadata);
+                if (!members.has((0, tool_catalog_identity_1.toolCatalogTargetKey)(metadata)))
+                    throw new Error(`Tool metadata must target a member of this publication: ${metadata.toolName}`);
+            }
+        }
+        await this.ready();
+        return this.enqueue(async () => {
+            this.validate(provider, registrations);
+            await this.materialize(registrations, false);
+            await prepare();
+            this.validate(provider, registrations);
+            await this.materialize(registrations, true, provider);
+            for (const metadata of toolMetadata) {
+                for (const toolId of (0, tool_catalog_migrations_1.toolCatalogIds)(metadata)) {
+                    const stored = await (0, tools_1.Tools)(this.dataContext).get(toolId);
+                    if (!stored || stored.catalogState !== "resolved")
+                        throw new Error(`Missing or quarantined tool identity: ${toolId}`);
+                    await this.refresh({ ...metadata, toolId }, stored, tools_1.toolCatalogSupplementalFields);
+                }
+            }
+            return this.guardActivation(new Map([[provider, registrations]]), activate);
+        });
+    }
+    async guardActivation(groups, activate) {
+        const expected = new Map();
+        for (const definition of this.definitions([...groups.values()].flat())) {
+            for (const tool of definition.tools) {
+                const target = {
+                    contractId: definition.contractId,
+                    version: definition.version,
+                    toolName: tool.name,
+                };
+                for (const toolId of (0, tool_catalog_migrations_1.toolCatalogIds)(target))
+                    expected.set(toolId, { toolId, ...resolvedFields(target, toolId) });
+            }
+        }
+        const table = (0, tools_1.Tools)(this.dataContext);
+        const validateRow = (toolId, row) => {
+            if (!row || row.catalogState === "quarantined")
+                throw new Error(`Missing or quarantined tool identity: ${toolId}`);
+            validateToolCatalogWrite(expected.get(toolId), row);
+        };
+        let conflict;
+        // Subscribe before reading so a later read cannot hide conflicting evidence
+        // seen during the snapshot or while the table gateway persists its schemas.
+        const subscription = table.dataChanged.subscribe((event) => {
+            const toolId = event.dataObject.toolId;
+            if (!expected.has(toolId))
+                return;
+            try {
+                validateRow(toolId, event.op === "delete" ? undefined : event.dataObject);
+            }
+            catch (error) {
+                conflict = error;
+            }
+        });
+        const assertCatalogCurrent = () => {
+            if (conflict)
+                throw conflict;
+            for (const [provider, registrations] of groups)
+                this.validate(provider, registrations);
+        };
+        try {
+            for (const toolId of expected.keys())
+                validateRow(toolId, await table.get(toolId));
+            assertCatalogCurrent();
+            return await activate(assertCatalogCurrent);
+        }
+        finally {
+            subscription.unsubscribe();
+        }
+    }
+    definitions(registrations) {
+        const definitions = new Map(registrations.map(({ definition }) => [
+            `${definition.contractId}@${definition.version}`,
+            definition,
+        ]));
+        for (const { alsoImplements = [] } of registrations) {
+            for (const declaration of alsoImplements) {
+                const range = declaration.version;
+                const from = typeof range === "number" ? range : range.from;
+                const to = typeof range === "number" ? range : range.to;
+                for (let version = from; version <= to; version++) {
+                    const key = `${declaration.contractId}@${version}`;
+                    const definition = definitions.get(key) ?? this.registry.getDefinition(declaration.contractId, version);
+                    if (!definition)
+                        throw new Error(`Missing alsoImplements definition: ${key}`);
+                    definitions.set(key, definition);
+                }
+            }
+        }
+        return [...definitions.values()];
+    }
+    /**
+     * Insert every public member's catalog rows, validating the batch first. With
+     * `refresh`, existing rows with absent or matching provider provenance also take the
+     * definition's name, usage description and IO schemas.
+     */
+    async materialize(registrations, refresh, provider) {
+        const table = (0, tools_1.Tools)(this.dataContext);
+        const existing = new Map((await table.list()).map((row) => [row.toolId, row]));
+        const identities = new Map();
+        // Reserve the entire reviewed inventory, even on an empty database.
+        for (const entry of tool_catalog_migrations_1.toolCatalogMigrations)
+            (0, tool_catalog_identity_1.validateToolCatalogCollision)(identities, entry.toolId, entry);
+        const candidates = new Map();
+        for (const definition of this.definitions(registrations)) {
+            const names = new Set();
+            for (const tool of definition.tools) {
+                if (names.has(tool.name))
+                    throw new Error(`Duplicate contract tool: ${tool.name}`);
+                names.add(tool.name);
+                const target = {
+                    contractId: definition.contractId,
+                    version: definition.version,
+                    toolName: tool.name,
+                };
+                (0, tool_catalog_identity_1.validateToolCatalogTarget)(target);
+                for (const toolId of (0, tool_catalog_migrations_1.toolCatalogIds)(target)) {
+                    (0, tool_catalog_identity_1.validateToolCatalogCollision)(identities, toolId, target);
+                    const row = {
+                        toolId,
+                        name: tool.name,
+                        usageDescription: tool.usageDescription,
+                        code: "",
+                        inputSchema: { type: tools_1.IOSchemaType.simple, fields: tool.inputFields },
+                        outputSchema: { type: tools_1.IOSchemaType.simple, fields: tool.outputFields },
+                        ...resolvedFields(target, toolId),
+                    };
+                    const stored = existing.get(toolId);
+                    if (stored?.catalogState === "quarantined")
+                        throw new Error(`Quarantined tool identity: ${toolId}`);
+                    validateToolCatalogWrite(stored, row);
+                    candidates.set(toolId, row);
+                }
+            }
+        }
+        // Validate the entire batch before the first write. Catalog metadata never
+        // overwrites provider-specific policy or another provider's descriptions.
+        for (const row of candidates.values()) {
+            // Older runtimes allowed provider removal to leave tombstones. Only a
+            // validated public target may restore one; insert-only still preserves any
+            // row that arrived concurrently, and the returned mapping is checked below.
+            const stored = await table.save(row, { insertOnly: true, restoreIfDeleted: true });
+            validateToolCatalogWrite(row, stored);
+            if (!stored || stored.catalogState === "quarantined")
+                throw new Error(`Catalog insert did not succeed: ${row.toolId}`);
+            if (refresh && (stored.packageId === undefined || stored.packageId === provider))
+                await this.refresh(row, stored, tools_1.toolCatalogContractDescriptiveFields);
+        }
+    }
+    /**
+     * Patch the listed descriptive fields whose stored values differ. A marked patch
+     * leaves every other column, including concurrently synced policy, untouched.
+     */
+    async refresh(desired, stored, fields) {
+        const changed = fields.filter((field) => !sameValue(stored[field], desired[field]));
+        if (!changed.length)
+            return;
+        const patch = { toolId: desired.toolId };
+        for (const field of changed)
+            Object.assign(patch, { [field]: desired[field] });
+        const refreshed = await (0, tools_1.Tools)(this.dataContext).update((0, tools_1.toolCatalogPatch)(patch));
+        validateToolCatalogWrite(stored, refreshed);
+        if (refreshed.catalogState === "quarantined")
+            throw new Error(`Quarantined tool identity: ${desired.toolId}`);
+    }
+    async reconcile() {
+        const table = (0, tools_1.Tools)(this.dataContext);
+        for (const row of await table.list()) {
+            let fields;
+            // Quarantine is sticky: conflicting evidence is never silently rehabilitated.
+            if (row.catalogState === "quarantined")
+                continue;
+            try {
+                validateToolCatalogWrite(undefined, row);
+                const target = (0, tool_catalog_migrations_1.resolveLegacyToolId)(row.toolId) ?? toolCatalogTarget(row);
+                fields = target ? resolvedFields(target, row.toolId) : { catalogState: "unresolved" };
+            }
+            catch (error) {
+                fields = { catalogState: "quarantined", catalogReason: String(error) };
+            }
+            if (Object.entries(fields).some(([key, value]) => row[key] !== value)) {
+                // Update only catalog-owned fields. A sync write may have changed legacy
+                // metadata since list() returned; writing the snapshot back would lose it.
+                await table.update((0, tools_1.toolCatalogPatch)({ toolId: row.toolId, ...fields }));
+            }
+        }
+    }
+    /**
+     * Patch supplemental metadata of existing system members, preserving identity,
+     * historical source and provenance, descriptions and all authorization policy.
+     * @throws If any entry is unresolved, quarantined or outside the system inventory.
+     */
+    async saveToolMetadata(entries) {
+        await this.ready();
+        await this.enqueue(async () => {
+            const members = (0, system_contracts_1.listSystemContracts)().flatMap((entry) => {
+                const definition = entry.getDefinition();
+                return definition.tools.map((tool) => ({
+                    contractId: definition.contractId,
+                    version: definition.version,
+                    toolName: tool.name,
+                }));
+            });
+            const rows = [];
+            for (const entry of entries) {
+                const target = (0, tool_catalog_migrations_1.resolveLegacyToolId)(entry.toolId) ??
+                    members.find((member) => (0, tool_catalog_migrations_1.toolCatalogIds)(member).includes(entry.toolId));
+                const stored = await (0, tools_1.Tools)(this.dataContext).get(entry.toolId);
+                if (!target ||
+                    !members.some((member) => (0, tool_catalog_identity_1.toolCatalogTargetKey)(member) === (0, tool_catalog_identity_1.toolCatalogTargetKey)(target)) ||
+                    !stored ||
+                    stored.catalogState !== "resolved")
+                    throw new Error(`Tool metadata requires a resolved system member: ${entry.toolId}`);
+                validateToolCatalogWrite(undefined, stored);
+                rows.push({ entry, stored });
+            }
+            for (const { entry, stored } of rows)
+                await this.refresh(entry, stored, tools_1.toolCatalogSupplementalFields);
+        });
+    }
+    /** Reject quarantined or conflicting retained evidence before a contract tool call. */
+    async assertTargetUsable(target) {
+        await this.ready();
+        for (const toolId of (0, tool_catalog_migrations_1.toolCatalogIds)(target)) {
+            const row = await (0, tools_1.Tools)(this.dataContext).get(toolId);
+            // Bare registry users may predate runtime catalog installation. Availability
+            // and authorization still come from the live registry and selected provider.
+            if (!row)
+                continue;
+            if (row.catalogState === "quarantined")
+                throw new Error(`Quarantined tool identity: ${toolId}`);
+            validateToolCatalogWrite({ toolId, ...resolvedFields(target, toolId) }, row);
+        }
+    }
+    /** Serialize host removal with pending publications while retaining all catalog rows. */
+    async removeProvider(provider, deactivate) {
+        // Join the same readiness boundary as publish(), including on a cold context,
+        // so an earlier install cannot enqueue its activation behind this removal.
+        await this.ready();
+        await this.enqueue(async () => {
+            this.registry.unregister(provider);
+            deactivate();
+        });
+    }
+    /** Stop subscriptions and queued lifecycle work; permanent rows are retained. */
+    async dispose() {
+        this.disposed = true;
+        this.subscription?.unsubscribe();
+        await this.tail;
+    }
+}
+exports.ToolCatalog = ToolCatalog;

package/dist/contracts/types.d.ts

@@ -1,10 +1,10 @@
 import type { Table } from "../data/orm/table";
 import type { ITableDefinition } from "../data/orm/table-definitions.type";
-import type { IToolInstance } from "../data/tools";
 import type { Event } from "../events";
 import type { Observable } from "../observable";
 import type { FieldType, IField } from "../types/field-type";
-import type { IContractConsumer, IContractConsumerBase } from "./contract-proxy";
+import type { IContractConsumer, IContractConsumerBase, IContractToolImplementation } from "./contract-proxy";
+import type { IToolCatalogMetadata } from "./tool-catalog";
 /**
  * A versioned interface definition declaring the shape of tables, tools,
  * observables, and events that a package provides. Pure data — no executable code.
@@ -52,6 +52,8 @@ export interface IContractTool {
      * account) are never gated by this value. Policy only — not part of shape validation.
      */
     remoteAccessLevel?: number;
+    /** Host-only invocation policy, excluded from shape identity. Requires an in-process workflow. */
+    requiresWorkflowRun?: boolean;
 }
 /** Observable value exposed by a contract. */
 export interface IContractObservable {
@@ -200,8 +202,8 @@ export interface IPackageDefinitionResult {
     /** Package-level items not part of any contract. */
     assistants: unknown[];
     appNavs: unknown[];
-    /** All executable tool instances across all contracts in this package. */
-    toolInstances: IToolInstance[];
+    /** Host descriptive metadata only; does not register executable tools or affect contract shape. */
+    toolMetadata?: IToolCatalogMetadata[];
     /** All table definitions across all contracts in this package. */
     tableDefinitions: ITableDefinition[];
 }
@@ -211,7 +213,7 @@ export interface IResolvedContract {
     version: number;
     providerPackageId: string;
     tables: Record<string, Table<any>>;
-    tools: Record<string, IToolInstance>;
+    tools: Record<string, IContractToolImplementation>;
     observables: Record<string, Observable<any>>;
     /** Live events the provider forwards from, keyed by contract event name. */
     events?: Record<string, Event<any>>;

package/dist/data/messages.d.ts

@@ -19,9 +19,9 @@ export declare const messageSchema: z.ZodObject<{
     messageId: string;
     assistantId?: string | undefined;
     messageParentId?: string | undefined;
-    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
     editedAt?: Date | undefined;
     fileIds?: string[] | undefined;
+    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
     message: string;
     userId: string;
@@ -30,9 +30,9 @@ export declare const messageSchema: z.ZodObject<{
     messageId: string;
     assistantId?: string | undefined;
     messageParentId?: string | undefined;
-    vars?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
     editedAt?: Date | undefined;
     fileIds?: string[] | undefined;
+    vars?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 export type IMessage = z.infer<typeof messageSchema>;
 export declare function Messages(dataContext?: DataContext): import("..").Table<{
@@ -43,9 +43,9 @@ export declare function Messages(dataContext?: DataContext): import("..").Table<
     messageId: string;
     assistantId?: string | undefined;
     messageParentId?: string | undefined;
-    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
     editedAt?: Date | undefined;
     fileIds?: string[] | undefined;
+    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 interface ISendMessageArgs {
     channelOrThreadIdOrWorkflowRunId: string;

package/dist/data/orm/sql.data-source.d.ts

@@ -5,6 +5,7 @@ import { type DataFilter, type ICursorIterable, type IDataQueryParams, type IDat
 import type { ISqlDb } from "./sql-db";
 import type { IDataChangedEvent } from "./subscribable.data-source";
 import { type ITableMetaData } from "./types";
+/** SQLite-backed table storage with additive schema migration and serialized initialization. */
 export declare class SQLDataSource<T extends {
     [key: string]: any;
 }> implements IDataSource<T> {
@@ -19,6 +20,7 @@ export declare class SQLDataSource<T extends {
     private ensureTableAndIndexesExist;
     private ensureTableIsNewest;
     private tableBuild;
+    /** Share schema initialization; a failed attempt is evicted so later calls can retry. */
     initTable(force?: boolean): Promise<boolean>;
     get(id: string): Promise<T | undefined>;
     list(filter?: DataFilter<T>, opts?: IDataQueryParams<T>): Promise<T[]>;
@@ -85,6 +87,9 @@ export declare class SQLDataSource<T extends {
      */
     bulkSave(records: T[]): Promise<T[]>;
 }
+/** Encode a JavaScript field for SQLite parameters or an escaped migration literal. */
 export declare function jsValueToSqlValue(value: any, escapeQuote?: boolean): any;
+/** Restore a SQLite field according to its declared Peers type. */
 export declare function sqlValueToJsValue(value: any, fieldType: FieldType, isArray: boolean): any;
+/** Default value used when adding a required field to an existing table. */
 export declare function globalDefaultValues(field: IField): {};