@elizaos/plugin-sql 2.0.3-beta.2 → 2.0.3-beta.3

package/src/dist/services/advanced-memory-storage.d.ts

@@ -0,0 +1,36 @@
+import { type IAgentRuntime, type MemoryStorageProvider, Service, type UUID } from "@elizaos/core";
+type LongTermMemoryRecord = Awaited<ReturnType<MemoryStorageProvider["storeLongTermMemory"]>>;
+type LongTermMemoryInput = Parameters<MemoryStorageProvider["storeLongTermMemory"]>[0];
+type LongTermMemoryCategory = LongTermMemoryRecord["category"];
+type SessionSummaryRecord = Awaited<ReturnType<MemoryStorageProvider["storeSessionSummary"]>>;
+type SessionSummaryInput = Parameters<MemoryStorageProvider["storeSessionSummary"]>[0];
+export declare class AdvancedMemoryStorageService extends Service implements MemoryStorageProvider {
+    static serviceType: "memoryStorage";
+    capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    private getMemoryWorldId;
+    private getLongTermRoomId;
+    private ensureMemoryWorld;
+    private ensureLongTermRoom;
+    private getEntityResolutionService;
+    private getIdentityGroup;
+    private getAnchorEntityId;
+    private parseLongTermMemory;
+    private parseSessionSummary;
+    private sortLongTermMemories;
+    private sortSessionSummaries;
+    storeLongTermMemory(memory: LongTermMemoryInput): Promise<LongTermMemoryRecord>;
+    getLongTermMemories(agentId: UUID, entityId: UUID, opts?: {
+        category?: LongTermMemoryCategory;
+        limit?: number;
+    }): Promise<LongTermMemoryRecord[]>;
+    updateLongTermMemory(id: UUID, agentId: UUID, entityId: UUID, updates: Partial<Omit<LongTermMemoryRecord, "id" | "agentId" | "entityId" | "createdAt">>): Promise<void>;
+    deleteLongTermMemory(id: UUID, agentId: UUID, entityId: UUID): Promise<void>;
+    storeSessionSummary(summary: SessionSummaryInput): Promise<SessionSummaryRecord>;
+    getCurrentSessionSummary(agentId: UUID, roomId: UUID): Promise<SessionSummaryRecord | null>;
+    updateSessionSummary(id: UUID, agentId: UUID, roomId: UUID, updates: Partial<Omit<SessionSummaryRecord, "id" | "agentId" | "roomId" | "createdAt" | "updatedAt">>): Promise<void>;
+    getSessionSummaries(agentId: UUID, roomId: UUID, limit?: number): Promise<SessionSummaryRecord[]>;
+}
+export {};

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

@@ -0,0 +1,64 @@
+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.js";
+interface GetOAuthFlowStateParams {
+    state?: string;
+    stateHash?: string;
+    flowId?: string;
+    agentId?: string;
+    provider?: string;
+    includeConsumed?: boolean;
+    includeExpired?: boolean;
+    now?: number | Date;
+}
+interface UpdateOAuthFlowStateParams {
+    state?: string;
+    stateHash?: string;
+    flowId?: string;
+    agentId?: string;
+    provider?: string;
+    accountId?: string | null;
+    redirectUri?: string | null;
+    codeVerifierRef?: string | null;
+    scopes?: string[];
+    metadata?: ConnectorAccountJsonObject;
+    expiresAt?: number | Date;
+    consumedAt?: number | Date | null;
+    consumedBy?: string | null;
+}
+interface DeleteOAuthFlowStateParams {
+    state?: string;
+    stateHash?: string;
+    flowId?: string;
+    agentId?: string;
+    provider?: string;
+}
+export interface ListConnectorAccountAuditEventsParams {
+    agentId?: string;
+    provider?: string;
+    accountId?: string;
+    action?: string;
+    outcome?: string;
+    limit?: number;
+}
+export declare class ConnectorAccountStore implements Store {
+    readonly ctx: StoreContext;
+    constructor(ctx: StoreContext);
+    private get db();
+    listAccounts(params?: ListConnectorAccountsParams): Promise<ConnectorAccountRecord[]>;
+    getAccount(params: GetConnectorAccountParams): Promise<ConnectorAccountRecord | null>;
+    upsertAccount(params: UpsertConnectorAccountParams): Promise<ConnectorAccountRecord>;
+    deleteAccount(params: DeleteConnectorAccountParams): Promise<boolean>;
+    findOwnerBinding(params: ConnectorOwnerBindingLookup): Promise<ConnectorOwnerBindingRecord | null>;
+    setCredentialRef(params: SetConnectorAccountCredentialRefParams): Promise<ConnectorAccountCredentialRefRecord>;
+    getCredentialRef(params: GetConnectorAccountCredentialRefParams): Promise<ConnectorAccountCredentialRefRecord | null>;
+    listCredentialRefs(params: ListConnectorAccountCredentialRefsParams): Promise<ConnectorAccountCredentialRefRecord[]>;
+    appendAuditEvent(params: AppendConnectorAccountAuditEventParams): Promise<ConnectorAccountAuditEventRecord>;
+    listAuditEvents(params?: ListConnectorAccountAuditEventsParams): Promise<ConnectorAccountAuditEventRecord[]>;
+    createOAuthFlowState(params: CreateOAuthFlowStateParams): Promise<OAuthFlowRecord>;
+    consumeOAuthFlowState(params: ConsumeOAuthFlowStateParams): Promise<OAuthFlowRecord | null>;
+    private buildOAuthFlowLookupConditions;
+    getOAuthFlowState(params: GetOAuthFlowStateParams): Promise<OAuthFlowRecord | null>;
+    updateOAuthFlowState(params: UpdateOAuthFlowStateParams): Promise<OAuthFlowRecord | null>;
+    deleteOAuthFlowState(params: DeleteOAuthFlowStateParams): Promise<boolean>;
+}
+export {};

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

@@ -0,0 +1,25 @@
+import type { UUID } from "@elizaos/core";
+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.
+ */
+export interface StoreContext {
+    /** Get the database instance (may be a transaction) */
+    getDb: () => DrizzleDatabase;
+    /** Execute operation with retry logic (context is for logging, ignored by adapter) */
+    withRetry: <T>(operation: () => Promise<T>, context?: string) => Promise<T>;
+    /** Execute operation within RLS isolation context */
+    withIsolationContext: <T>(entityId: UUID | null, callback: (tx: DrizzleDatabase) => Promise<T>) => Promise<T>;
+    /** Current agent ID */
+    agentId: UUID;
+    /** Get current embedding dimension column (dynamic to reflect runtime changes) */
+    getEmbeddingDimension: () => EmbeddingDimensionColumn;
+}
+/**
+ * Base interface for all domain stores.
+ */
+export interface Store {
+    readonly ctx: StoreContext;
+}

package/src/dist/types.d.ts

@@ -0,0 +1,13 @@
+import type { IDatabaseAdapter } from "@elizaos/core";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { PgliteDatabase } from "drizzle-orm/pglite";
+export type DrizzleDatabase = NodePgDatabase | PgliteDatabase;
+export interface IDatabaseClientManager<T> {
+    initialize(): Promise<void>;
+    getConnection(): T;
+    close(): Promise<void>;
+}
+export declare function getDb(adapter: IDatabaseAdapter): DrizzleDatabase;
+export declare function getRow<T>(result: {
+    rows: unknown[];
+}, index?: number): T | undefined;

package/src/dist/utils/string-to-uuid.d.ts

@@ -0,0 +1,2 @@
+import type { UUID } from "@elizaos/core";
+export declare function stringToUuid(target: string | number): UUID;

package/src/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function expandTildePath(filepath: string): string;
+export declare function resolveEnvFile(startDir?: string): string;
+export declare function resolvePgliteDir(dir?: string, fallbackDir?: string): string;
+export declare function sanitizeJsonObject(value: unknown, seen?: WeakSet<object>): unknown;

package/src/dist/utils.node.d.ts

@@ -0,0 +1,4 @@
+export declare function expandTildePath(filepath: string): string;
+export declare function resolveEnvFile(startDir?: string): string;
+export declare function resolvePgliteDir(dir?: string, fallbackDir?: string): string;
+export declare function sanitizeJsonObject(value: unknown, seen?: WeakSet<object>): unknown;

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;
+}