@elizaos/plugin-sql 2.0.0-beta.1 → 2.0.3-beta.3

package/src/dist/pg/adapter.d.ts

@@ -1,9 +1,9 @@
 import { type Agent, type Component, type Entity, type Memory, type UUID } from "@elizaos/core";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { Pool } from "pg";
-import { BaseDrizzleAdapter } from "../base";
-import { type EmbeddingDimensionColumn } from "../schema/embedding";
-import type { PostgresConnectionManager } from "./manager";
+import { BaseDrizzleAdapter } from "../base.js";
+import { type EmbeddingDimensionColumn } from "../schema/embedding.js";
+import type { PostgresConnectionManager } from "./manager.js";
 export declare class PgDatabaseAdapter extends BaseDrizzleAdapter {
     protected embeddingDimension: EmbeddingDimensionColumn;
     private manager;
@@ -11,7 +11,7 @@ export declare class PgDatabaseAdapter extends BaseDrizzleAdapter {
     getManager(): PostgresConnectionManager;
     withEntityContext<T>(entityId: UUID | null, callback: (tx: NodePgDatabase) => Promise<T>): Promise<T>;
     getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    getMemoriesByServerId(_params: {
+    getMemoriesByServerId(params: {
         serverId: UUID;
         count?: number;
     }): Promise<Memory[]>;

package/src/dist/pg/sslmode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * pg-connection-string currently treats these sslmode values like verify-full,
+ * but warns that its next major version will switch them to libpq semantics.
+ * Make the current strict TLS behavior explicit before node-postgres parses it.
+ */
+export declare function normalizePgSslMode(connectionString: string): string;

package/src/dist/pglite/adapter.d.ts

@@ -1,16 +1,16 @@
 import type { PGlite } from "@electric-sql/pglite";
-import { type Agent, type Entity, type Memory, type UUID } from "@elizaos/core";
+import { type Agent, type Entity, type Memory, type MemoryMetadata, type Relationship, type Room, type Task, type UUID, type World } from "@elizaos/core";
 import { type PgliteDatabase } from "drizzle-orm/pglite";
-import { BaseDrizzleAdapter } from "../base";
-import { type EmbeddingDimensionColumn } from "../schema/embedding";
-import type { PGliteClientManager } from "./manager";
+import { BaseDrizzleAdapter } from "../base.js";
+import { type EmbeddingDimensionColumn } from "../schema/embedding.js";
+import type { PGliteClientManager } from "./manager.js";
 export declare class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     private manager;
     protected embeddingDimension: EmbeddingDimensionColumn;
     constructor(agentId: UUID, manager: PGliteClientManager);
     withEntityContext<T>(_entityId: UUID | null, callback: (tx: PgliteDatabase) => Promise<T>): Promise<T>;
     getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    getMemoriesByServerId(_params: {
+    getMemoriesByServerId(params: {
         serverId: UUID;
         count?: number;
     }): Promise<Memory[]>;
@@ -21,4 +21,43 @@ export declare class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     close(): Promise<void>;
     getConnection(): Promise<PgliteDatabase>;
     getRawConnection(): PGlite;
+    createAgent(agent: Agent): Promise<boolean>;
+    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
+    deleteAgent(agentId: UUID): Promise<boolean>;
+    deleteAgents(agentIds: UUID[]): Promise<boolean>;
+    createEntities(entities: Entity[]): Promise<UUID[]>;
+    updateEntity(entity: Entity): Promise<void>;
+    deleteEntity(entityId: UUID): Promise<void>;
+    createWorld(world: World): Promise<UUID>;
+    updateWorld(world: World): Promise<void>;
+    removeWorld(id: UUID): Promise<void>;
+    createRooms(rooms: Room[]): Promise<UUID[]>;
+    updateRoom(room: Room): Promise<void>;
+    deleteRoom(roomId: UUID): Promise<void>;
+    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    createMemory(memory: Memory & {
+        metadata?: MemoryMetadata;
+    }, tableName: string): Promise<UUID>;
+    updateMemory(memory: Partial<Memory> & {
+        id: UUID;
+        metadata?: MemoryMetadata;
+    }): Promise<boolean>;
+    deleteMemory(memoryId: UUID): Promise<void>;
+    deleteManyMemories(memoryIds: UUID[]): Promise<void>;
+    deleteAllMemories(roomIds: UUID[], tableName: string): Promise<void>;
+    deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
+    createRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+        tags?: string[];
+        metadata?: {
+            [key: string]: unknown;
+        };
+    }): Promise<boolean>;
+    updateRelationship(relationship: Relationship): Promise<void>;
+    deleteRelationships(relationshipIds: UUID[]): Promise<void>;
+    createTask(task: Task): Promise<UUID>;
+    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
+    deleteTask(id: UUID): Promise<void>;
 }

package/src/dist/pglite/manager.d.ts

@@ -1,6 +1,60 @@
 import { PGlite, type PGliteOptions } from "@electric-sql/pglite";
-import type { IDatabaseClientManager } from "../types";
+import type { IDatabaseClientManager } from "../types.js";
+import { WriteBackService } from "../write-back/index.js";
+/**
+ * Canonical list of table names synced via Electric and tracked by the
+ * write-back service. Used by both syncShapesToTables (read path) and
+ * PgliteDatabaseAdapter (write path) so the two stay in sync.
+ */
+export declare const SYNCED_TABLE_NAMES: readonly ["agents", "entities", "worlds", "rooms", "participants", "memories", "relationships", "tasks"];
+/**
+ * Runtime sync status of the Electric Sync client wired into PGlite.
+ * - syncing: the sync stream is connecting or catching up with the source.
+ * - synced: the local PGlite is up-to-date with the Electric source.
+ * - error: the sync stream encountered a non-recoverable error.
+ * - disabled: no ELIZA_ELECTRIC_SYNC_URL was configured at boot.
+ */
+export type PgliteSyncStatus = "syncing" | "synced" | "error" | "disabled";
+/** Per-table sync state. */
+export type PgliteSyncTableState = "pending" | "synced" | "error";
+/** Per-table status map exposed by getSyncStatus(). */
+export type PgliteSyncTableStatus = Record<string, {
+    state: PgliteSyncTableState;
+    error?: string;
+}>;
+/**
+ * Result row type for live queries. Matches the shape returned by
+ * {@link https://pglite.dev/docs/live-queries | pg.live.query()}.
+ */
+export interface LiveQueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    fields: {
+        name: string;
+        dataTypeID: number;
+    }[];
+    affectedRows?: number;
+}
+/**
+ * Return value from {@link https://pglite.dev/docs/live-queries | pg.live.query()}.
+ */
+export interface LiveQueryReturn<T = Record<string, unknown>> {
+    initialResults: LiveQueryResult<T>;
+    unsubscribe: () => Promise<void>;
+    refresh: (options?: {
+        offset?: number;
+        limit?: number;
+    }) => Promise<void>;
+}
+/**
+ * The `pg.live` namespace added by the `@electric-sql/pglite/live` extension.
+ */
+export interface LiveNamespace {
+    query<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, callback: (result: LiveQueryResult<T>) => void): Promise<LiveQueryReturn<T>>;
+    incrementalQuery<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, key: string, callback: (result: LiveQueryResult<T>) => void): Promise<LiveQueryReturn<T>>;
+    changes<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, key: string, callback: (changes: unknown[]) => void): Promise<LiveQueryReturn<T>>;
+}
 export declare class PGliteClientManager implements IDatabaseClientManager<PGlite> {
+    private static readonly LOCK_STALE_MS;
     private client;
     private options;
     private shuttingDown;
@@ -8,8 +62,50 @@ export declare class PGliteClientManager implements IDatabaseClientManager<PGlit
     private initializePromise;
     private lockFd;
     private lockPath;
-    constructor(options: PGliteOptions);
+    private syncUrl;
+    private agentId;
+    private syncStatus;
+    private syncError;
+    private syncUnsubscribe;
+    private syncTableStates;
+    private syncedTables;
+    private startSyncMutex;
+    private forceResyncMutex;
+    private writeBack;
+    constructor(options: PGliteOptions & {
+        syncUrl?: string;
+        agentId?: string;
+        writeBackBaseUrl?: string;
+        serviceKey?: string;
+    });
     getConnection(): PGlite;
+    /**
+     * Access the write-back service for forwarding local writes to the
+     * cloud API. Returns null when write-back is not configured.
+     */
+    getWriteBack(): WriteBackService | null;
+    /**
+     * Notify the write-back service of a local write to a sync table.
+     * Called by the adapter after a successful write operation.
+     * No-op when write-back is not configured.
+     */
+    notifyWrite(table: string, operation: "insert" | "upsert" | "delete", row: Record<string, unknown>): void;
+    /**
+     * Current Electric Sync status.
+     * - "disabled": no ELIZA_ELECTRIC_SYNC_URL was configured.
+     * - "syncing": sync client is connecting or catching up.
+     * - "synced": local PGlite is up-to-date with the Electric source.
+     * - "error": sync encountered an error (see syncError).
+     *
+     * Also returns per-table state so operators can see which specific
+     * tables are healthy vs errored vs still pending.
+     */
+    getSyncStatus(): {
+        status: PgliteSyncStatus;
+        error: string | null;
+        tables: PgliteSyncTableStatus;
+        synced: string[];
+    };
     isShuttingDown(): boolean;
     isInitialized(): boolean;
     initialize(): Promise<void>;
@@ -19,8 +115,28 @@ export declare class PGliteClientManager implements IDatabaseClientManager<PGlit
     private getDataDir;
     private isFileBackedDataDir;
     private getDataDirLockPath;
-    private getLockPid;
-    private isPidRunning;
+    private getLockInfo;
+    /**
+     * Decide whether an existing lock should be honored as held by a live owner.
+     *
+     * Single-writer safety comes first: a *confirmed-running* PID is always
+     * honored, regardless of how old its `createdAt` is. A long-running agent
+     * (days or weeks of uptime) must never have its live lock reclaimed by a
+     * second manager — that would open a dual-writer window, which is
+     * unrecoverable, whereas a falsely-bricked boot is recoverable by removing
+     * the lock file. This matches the sibling `reconcilePglitePidFile`, which
+     * also treats a live PID as "active".
+     *
+     * The staleness window only rescues the *unconfirmable* case. A bare
+     * `process.kill(pid, 0)` is vulnerable to PID reuse, and a recycled
+     * cross-user PID surfaces as `EPERM` (or another non-`ESRCH` error) rather
+     * than a clean success. For those we cannot prove the PID belongs to a live
+     * Eliza process, so we fall back to `createdAt`: a recent lock is still
+     * respected, but one older than `LOCK_STALE_MS` (or with no usable timestamp)
+     * is treated as stale and reclaimed so an aliased PID cannot brick boot
+     * forever. `ESRCH` is unambiguous — the process is gone and the lock is stale.
+     */
+    private isLockActive;
     private acquireDataDirLockIfNeeded;
     private releaseDataDirLock;
     private getErrorText;
@@ -28,5 +144,70 @@ export declare class PGliteClientManager implements IDatabaseClientManager<PGlit
     private createActiveLockError;
     private createManualResetRequiredError;
     private queryMigrationsSchema;
+    /**
+     * Ensure the Electric Sync stream is started. Idempotent — safe to call
+     * on every database operation. The first call after PGlite is initialized
+     * and after migrations have created the target tables will start the sync
+     * stream; subsequent calls are no-ops.
+     *
+     * This is deliberately separate from {@link initialize} because the Drizzle
+     * migrations that create the target tables run AFTER plugin init completes.
+     * Starting sync during init would try to insert into non-existent tables.
+     */
+    ensureSync(): Promise<void>;
+    /**
+     * Access the PGlite live query namespace for reactive queries that
+     * push updated results whenever the underlying tables change. Useful
+     * for dashboard health endpoints and real-time monitoring.
+     *
+     * Returns the {@link https://pglite.dev/docs/live-queries | pg.live}
+     * namespace, which provides:
+     *   - `live.query(sql, params, callback)` — simple live query
+     *   - `live.incrementalQuery(sql, params, key, callback)` — diff-based
+     *   - `live.changes(sql, params, key, callback)` — raw change stream
+     *
+     * Returns null when PGlite extensions are disabled.
+     */
+    liveQuery(): LiveNamespace | null;
+    /**
+     * Force-reset the Electric Sync stream: unsubscribe, drop all internal
+     * sync state from the `electric` schema, and restart from scratch.
+     *
+     * Use this when operators diagnose a split-brain scenario (local PGlite
+     * has diverged from the source Postgres) or when the sync stream is
+     * stuck in an unrecoverable error state. The local data in the synced
+     * tables is preserved — only the Electric metadata tables are dropped,
+     * forcing a full re-sync that reconstructs state from the source.
+     *
+     * Returns the sync status after the reset. When sync is not configured
+     * (no ELIZA_ELECTRIC_SYNC_URL), returns null.
+     */
+    forceResync(): Promise<{
+        status: PgliteSyncStatus;
+        error: string | null;
+        tables: PgliteSyncTableStatus;
+        synced: string[];
+    } | null>;
+    private forceResyncInternal;
+    /**
+     * Start the Electric Sync stream after PGlite is initialized.
+     * Uses the official multi-table {@link https://pglite.dev/docs/sync#multi-table-sync | syncShapesToTables}
+     * API so all shape updates that happened in a single Postgres transaction
+     * are applied in a single PGlite transaction, preserving consistency
+     * across all runtime tables.
+     *
+     * Each shape is filtered by agent_id so that in a shared-Neon deployment
+     * an agent only syncs its own data — preserving per-agent physical isolation
+     * even though the source Postgres is multi-tenant.
+     *
+     * Sync failures are non-fatal: the agent runs on its local PGlite
+     * regardless of sync health. Per-table error state is tracked so
+     * operators can diagnose individual table issues without assuming
+     * the entire sync is broken.
+     */
+    private startSync;
+    /** Internal body of startSync, extracted so the mutex wraps only the
+     *  syncShapesToTables call, not the early-return guards. */
+    private startSyncInternal;
     private initializeInternal;
 }

package/src/dist/runtime-migrator/drizzle-adapters/database-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDB, SchemaSnapshot } from "../types";
+import type { DrizzleDB, SchemaSnapshot } from "../types.js";
 /**
  * Introspect the current database state and generate a snapshot
  * This is used when no previous snapshot exists for a plugin

package/src/dist/runtime-migrator/drizzle-adapters/diff-calculator.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaCheckConstraint, SchemaColumn, SchemaForeignKey, SchemaIndex, SchemaSnapshot, SchemaUniqueConstraint } from "../types";
+import type { SchemaCheckConstraint, SchemaColumn, SchemaForeignKey, SchemaIndex, SchemaSnapshot, SchemaUniqueConstraint } from "../types.js";
 export interface ColumnChanges {
     typeChanged?: boolean;
     prevType?: string;

package/src/dist/runtime-migrator/drizzle-adapters/snapshot-generator.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaSnapshot } from "../types";
+import type { SchemaSnapshot } from "../types.js";
 type DrizzleSchema = Record<string, unknown>;
 /**
  * Generate a snapshot from a Drizzle schema

package/src/dist/runtime-migrator/drizzle-adapters/sql-generator.d.ts

@@ -1,5 +1,5 @@
-import type { SchemaSnapshot } from "../types";
-import type { SchemaDiff } from "./diff-calculator";
+import type { SchemaSnapshot } from "../types.js";
+import type { SchemaDiff } from "./diff-calculator.js";
 /**
  * Data loss detection result
  * Based on Drizzle's pgPushUtils approach

package/src/dist/runtime-migrator/extension-manager.d.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDB } from "./types";
+import type { DrizzleDB } from "./types.js";
 export declare class ExtensionManager {
     private db;
     constructor(db: DrizzleDB);

package/src/dist/runtime-migrator/index.d.ts

@@ -1,8 +1,8 @@
-export { calculateDiff, hasDiffChanges, type SchemaDiff, } from "./drizzle-adapters/diff-calculator";
-export { createEmptySnapshot, generateSnapshot, hasChanges, hashSnapshot, } from "./drizzle-adapters/snapshot-generator";
-export { generateMigrationSQL, generateRenameColumnSQL, generateRenameTableSQL, } from "./drizzle-adapters/sql-generator";
-export { RuntimeMigrator } from "./runtime-migrator";
-export { JournalStorage } from "./storage/journal-storage";
-export { MigrationTracker } from "./storage/migration-tracker";
-export { SnapshotStorage } from "./storage/snapshot-storage";
-export * from "./types";
+export { calculateDiff, hasDiffChanges, type SchemaDiff, } from "./drizzle-adapters/diff-calculator.js";
+export { createEmptySnapshot, generateSnapshot, hasChanges, hashSnapshot, } from "./drizzle-adapters/snapshot-generator.js";
+export { generateMigrationSQL, generateRenameColumnSQL, generateRenameTableSQL, } from "./drizzle-adapters/sql-generator.js";
+export { RuntimeMigrator } from "./runtime-migrator.js";
+export { JournalStorage } from "./storage/journal-storage.js";
+export { MigrationTracker } from "./storage/migration-tracker.js";
+export { SnapshotStorage } from "./storage/snapshot-storage.js";
+export * from "./types.js";

package/src/dist/runtime-migrator/runtime-migrator.d.ts

@@ -1,5 +1,5 @@
-import { type DataLossCheck } from "./drizzle-adapters/sql-generator";
-import type { DrizzleDB, RuntimeMigrationOptions } from "./types";
+import { type DataLossCheck } from "./drizzle-adapters/sql-generator.js";
+import type { DrizzleDB, RuntimeMigrationOptions } from "./types.js";
 export declare class RuntimeMigrator {
     private db;
     private migrationTracker;

package/src/dist/runtime-migrator/storage/journal-storage.d.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDB, Journal, JournalEntry } from "../types";
+import type { DrizzleDB, Journal, JournalEntry } from "../types.js";
 export declare class JournalStorage {
     private db;
     constructor(db: DrizzleDB);

package/src/dist/runtime-migrator/storage/migration-tracker.d.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDB } from "../types";
+import type { DrizzleDB } from "../types.js";
 export declare class MigrationTracker {
     private db;
     constructor(db: DrizzleDB);

package/src/dist/runtime-migrator/storage/snapshot-storage.d.ts

@@ -1,4 +1,4 @@
-import type { DrizzleDB, SchemaSnapshot } from "../types";
+import type { DrizzleDB, SchemaSnapshot } from "../types.js";
 export declare class SnapshotStorage {
     private db;
     constructor(db: DrizzleDB);

package/src/dist/schema/agent.d.ts

@@ -289,7 +289,7 @@ export declare const agentTable: import("drizzle-orm/pg-core").PgTableWithColumn
             dataType: "json";
             columnType: "PgJsonb";
             data: {
-                [key: string]: string | number | boolean | Record<string, unknown>;
+                [key: string]: string | number | boolean | Record<string, unknown> | undefined;
                 secrets?: {
                     [key: string]: string | boolean | number;
                 };
@@ -306,7 +306,7 @@ export declare const agentTable: import("drizzle-orm/pg-core").PgTableWithColumn
             generated: undefined;
         }, {}, {
             $type: {
-                [key: string]: string | number | boolean | Record<string, unknown>;
+                [key: string]: string | number | boolean | Record<string, unknown> | undefined;
                 secrets?: {
                     [key: string]: string | boolean | number;
                 };

package/src/dist/schema/approvalRequests.d.ts

@@ -1,7 +1,7 @@
 /**
  * Persistent backing store for the LifeOps human-in-the-loop approval queue.
  *
- * Owned by `plugins/app-lifeops` (see `src/lifeops/approval-queue.types.ts`),
+ * Owned by `plugins/plugin-personal-assistant` (see `src/lifeops/approval-queue.types.ts`),
  * but lives in plugin-sql so the runtime migrator picks it up automatically
  * for both PostgreSQL and PGlite deployments.
  *

package/src/dist/schema/embedding.d.ts

@@ -4,6 +4,7 @@ export declare const VECTOR_DIMS: {
     readonly LARGE: 768;
     readonly XL: 1024;
     readonly XXL: 1536;
+    readonly XXL2: 2048;
     readonly XXXL: 3072;
 };
 export declare const DIMENSION_MAP: {
@@ -12,6 +13,7 @@ export declare const DIMENSION_MAP: {
     readonly 768: "dim768";
     readonly 1024: "dim1024";
     readonly 1536: "dim1536";
+    readonly 2048: "dim2048";
     readonly 3072: "dim3072";
 };
 /**
@@ -168,6 +170,25 @@ export declare const embeddingTable: import("drizzle-orm/pg-core").PgTableWithCo
         }, {}, {
             dimensions: 1536;
         }>;
+        dim2048: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dim_2048";
+            tableName: "embeddings";
+            dataType: "array";
+            columnType: "PgVector";
+            data: number[];
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            dimensions: 2048;
+        }>;
         dim3072: import("drizzle-orm/pg-core").PgColumn<{
             name: "dim_3072";
             tableName: "embeddings";
@@ -194,7 +215,7 @@ export declare const embeddingTable: import("drizzle-orm/pg-core").PgTableWithCo
  * Defines the possible values for the Embedding Dimension Column.
  * It can be "dim384", "dim512", "dim768", "dim1024", "dim1536", or "dim3072".
  */
-export type EmbeddingDimensionColumn = "dim384" | "dim512" | "dim768" | "dim1024" | "dim1536" | "dim3072";
+export type EmbeddingDimensionColumn = "dim384" | "dim512" | "dim768" | "dim1024" | "dim1536" | "dim2048" | "dim3072";
 /**
  * Retrieve the type of a specific column in the EmbeddingTable based on the EmbeddingDimensionColumn key.
  */

package/src/dist/schema/index.d.ts

@@ -1,35 +1,35 @@
-export { agentTable } from "./agent";
-export { approvalRequestTable } from "./approvalRequests";
-export type { AuthAuditOutcome } from "./authAuditEvent";
-export { authAuditEventTable } from "./authAuditEvent";
-export { authBootstrapJtiSeenTable } from "./authBootstrapJti";
-export type { AuthIdentityKind } from "./authIdentity";
-export { authIdentityCreatedAtDefault, authIdentityTable, } from "./authIdentity";
-export { authOwnerBindingTable } from "./authOwnerBinding";
-export { authOwnerLoginTokenTable } from "./authOwnerLoginToken";
-export type { AuthSessionKind } from "./authSession";
-export { authSessionTable } from "./authSession";
-export { cacheTable } from "./cache";
-export { channelTable } from "./channel";
-export { channelParticipantsTable } from "./channelParticipant";
-export { componentTable } from "./component";
-export { connectorAccountAuditEventsTable, connectorAccountCredentialsTable, connectorAccountsTable, oauthFlowsTable, } from "./connectorAccounts";
-export { embeddingTable } from "./embedding";
-export { entityTable } from "./entity";
-export { entityIdentityTable, entityMergeCandidateTable, factCandidateTable, } from "./entityIdentity";
-export { logTable } from "./log";
-export { longTermMemories } from "./longTermMemories";
-export { memoryTable } from "./memory";
-export { memoryAccessLogs } from "./memoryAccessLogs";
-export { messageTable } from "./message";
-export { messageServerTable } from "./messageServer";
-export { messageServerAgentsTable } from "./messageServerAgent";
-export { pairingAllowlistTable } from "./pairingAllowlist";
-export { pairingRequestTable } from "./pairingRequest";
-export { participantTable } from "./participant";
-export { relationshipTable } from "./relationship";
-export { roomTable } from "./room";
-export { serverTable } from "./server";
-export { sessionSummaries } from "./sessionSummaries";
-export { taskTable } from "./tasks";
-export { worldTable } from "./world";
+export { agentTable } from "./agent.js";
+export { approvalRequestTable } from "./approvalRequests.js";
+export type { AuthAuditOutcome } from "./authAuditEvent.js";
+export { authAuditEventTable } from "./authAuditEvent.js";
+export { authBootstrapJtiSeenTable } from "./authBootstrapJti.js";
+export type { AuthIdentityKind } from "./authIdentity.js";
+export { authIdentityCreatedAtDefault, authIdentityTable, } from "./authIdentity.js";
+export { authOwnerBindingTable } from "./authOwnerBinding.js";
+export { authOwnerLoginTokenTable } from "./authOwnerLoginToken.js";
+export type { AuthSessionKind } from "./authSession.js";
+export { authSessionTable } from "./authSession.js";
+export { cacheTable } from "./cache.js";
+export { channelTable } from "./channel.js";
+export { channelParticipantsTable } from "./channelParticipant.js";
+export { componentTable } from "./component.js";
+export { connectorAccountAuditEventsTable, connectorAccountCredentialsTable, connectorAccountsTable, oauthFlowsTable, } from "./connectorAccounts.js";
+export { embeddingTable } from "./embedding.js";
+export { entityTable } from "./entity.js";
+export { entityIdentityTable, entityMergeCandidateTable, factCandidateTable, } from "./entityIdentity.js";
+export { logTable } from "./log.js";
+export { longTermMemories } from "./longTermMemories.js";
+export { memoryTable } from "./memory.js";
+export { memoryAccessLogs } from "./memoryAccessLogs.js";
+export { messageTable } from "./message.js";
+export { messageServerTable } from "./messageServer.js";
+export { messageServerAgentsTable } from "./messageServerAgent.js";
+export { pairingAllowlistTable } from "./pairingAllowlist.js";
+export { pairingRequestTable } from "./pairingRequest.js";
+export { participantTable } from "./participant.js";
+export { relationshipTable } from "./relationship.js";
+export { roomTable } from "./room.js";
+export { serverTable } from "./server.js";
+export { sessionSummaries } from "./sessionSummaries.js";
+export { taskTable } from "./tasks.js";
+export { worldTable } from "./world.js";

package/src/dist/schema/types.d.ts

@@ -15,7 +15,7 @@ export declare const stringJsonb: {
         driverParam: string;
         enumValues: undefined;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
         name: "";
         dataType: "custom";
         columnType: "PgCustomColumn";
@@ -49,7 +49,7 @@ export declare const numberTimestamp: {
         driverParam: string;
         enumValues: undefined;
     }>;
-    <TConfig extends Record<string, any>>(fieldConfig?: TConfig): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
         name: "";
         dataType: "custom";
         columnType: "PgCustomColumn";

package/src/dist/stores/connectorAccount.store.d.ts

@@ -1,5 +1,5 @@
 import type { AppendConnectorAccountAuditEventParams, ConnectorAccountAuditEventRecord, ConnectorAccountCredentialRefRecord, ConnectorAccountJsonObject, ConnectorAccountRecord, ConnectorOwnerBindingLookup, ConnectorOwnerBindingRecord, ConsumeOAuthFlowStateParams, CreateOAuthFlowStateParams, DeleteConnectorAccountParams, GetConnectorAccountCredentialRefParams, GetConnectorAccountParams, ListConnectorAccountCredentialRefsParams, ListConnectorAccountsParams, OAuthFlowRecord, SetConnectorAccountCredentialRefParams, UpsertConnectorAccountParams } from "@elizaos/core";
-import type { Store, StoreContext } from "./types";
+import type { Store, StoreContext } from "./types.js";
 interface GetOAuthFlowStateParams {
     state?: string;
     stateHash?: string;

package/src/dist/stores/types.d.ts

@@ -1,6 +1,6 @@
 import type { UUID } from "@elizaos/core";
-import type { EmbeddingDimensionColumn } from "../schema/embedding";
-import type { DrizzleDatabase } from "../types";
+import type { EmbeddingDimensionColumn } from "../schema/embedding.js";
+import type { DrizzleDatabase } from "../types.js";
 /**
  * Context passed to all stores for database operations.
  * Stores don't manage connections - they receive a context from the adapter.

package/src/dist/write-back/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * WriteBackService — implements Electric's Pattern 1 (Online Writes).
+ *
+ * When an agent writes to its local PGlite, this service asynchronously
+ * forwards the write to the cloud API, which inserts it into the central
+ * Postgres. Electric then syncs the confirmed row back to PGlite via the
+ * existing syncShapesToTables read path, completing the round-trip.
+ *
+ * Writes are fire-and-forget — the agent never blocks on the HTTP POST.
+ * A small in-memory queue batches writes that arrive while a flush is
+ * in-flight, avoiding duplicate concurrent POSTs. Writes that fail are
+ * retried up to MAX_RETRIES times, then dropped with a warning log.
+ *
+ * Configured via:
+ *   ELIZA_CLOUD_WRITE_BASE_URL — base URL of the cloud API, e.g.
+ *     https://api.elizacloud.ai. The agentId is appended at runtime:
+ *     {base}/api/v1/eliza/agents/{agentId}/write
+ *   ELIZA_CLOUD_SERVICE_KEY — X-Service-Key value (WAIFU_SERVICE_KEY)
+ *
+ * If neither env var is set, the service is a no-op.
+ */
+export interface WriteBackOptions {
+    /** Base URL of the cloud API. AgentId is appended at runtime. */
+    writeBaseUrl?: string | null;
+    /** Agent UUID for constructing the write endpoint URL. */
+    agentId?: string | null;
+    /** X-Service-Key value for authentication. */
+    serviceKey?: string | null;
+}
+export declare class WriteBackService {
+    private writeUrl;
+    private serviceKey;
+    private queue;
+    private flushing;
+    private flushTimer;
+    /** Incrementing counter ensures unique writeIds even without crypto. */
+    private writeCounter;
+    constructor(opts?: WriteBackOptions);
+    /** Whether the service is configured and active. */
+    get enabled(): boolean;
+    /**
+     * Enqueue a write to be forwarded to the cloud API.
+     * Returns immediately; the write is flushed asynchronously.
+     */
+    enqueue(table: string, operation: "insert" | "upsert" | "delete", row: Record<string, unknown>): void;
+    /**
+     * Flush all pending writes synchronously. Waits for any in-progress
+     * drain to complete, then picks up any remaining items.
+     * Used during shutdown to drain the queue before the agent exits.
+     */
+    flush(): Promise<void>;
+    private scheduleFlush;
+    private drainQueue;
+    private sendBatch;
+    private requeueOrDrop;
+}