@elizaos/plugin-sql 2.0.0-alpha.2 → 2.0.0-alpha.20

package/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/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/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/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/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/drizzle/index.ts

@@ -0,0 +1,17 @@
+export {
+  and,
+  asc,
+  count,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNull,
+  lt,
+  lte,
+  ne,
+  or,
+  type SQL,
+  sql,
+} from "drizzle-orm";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/plugin-sql",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.20",
   "type": "module",
   "main": "dist/node/index.node.js",
   "module": "dist/node/index.node.js",
@@ -32,45 +32,67 @@
         "default": "./dist/node/index.node.js"
       },
       "default": "./dist/node/index.node.js"
+    },
+    "./schema": {
+      "types": "./schema/index.ts",
+      "import": "./schema/index.ts",
+      "default": "./schema/index.ts"
+    },
+    "./drizzle": {
+      "types": "./drizzle/index.ts",
+      "import": "./drizzle/index.ts",
+      "default": "./drizzle/index.ts"
+    },
+    "./types": {
+      "types": "./types.ts",
+      "import": "./types.ts",
+      "default": "./types.ts"
     }
   },
   "sideEffects": false,
   "files": [
     "dist",
     "drizzle",
-    "types"
+    "schema",
+    "types.ts"
   ],
   "dependencies": {
-    "@electric-sql/pglite": "^0.3.3",
-    "@elizaos/core": "2.0.0-alpha.2",
+    "@electric-sql/pglite": "^0.4.0",
+    "@elizaos/core": "^2.0.0-alpha.537",
+    "@neondatabase/serverless": "^1.1.0",
     "dotenv": "^17.2.3",
     "drizzle-kit": "^0.31.8",
-    "drizzle-orm": "^0.45.1",
+    "drizzle-orm": "0.45.2",
     "pg": "^8.16.3",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
+    "@types/bun": "^1.3.5",
+    "@biomejs/biome": "^2.4.14",
     "@types/node": "^25.0.3",
     "@types/pg": "^8.15.6",
-    "typescript": "^5.9.3"
+    "@types/ws": "^8.18.1",
+    "typescript": "^6.0.0",
+    "vitest": "^4.0.0"
   },
   "scripts": {
     "dev": "bun run build.ts --watch",
     "migrate:generate": "drizzle-kit generate",
     "migrate": "drizzle-kit migrate",
-    "typecheck": "tsc --noEmit -p tsconfig.json || true",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json *.tsbuildinfo",
-    "format": "bunx @biomejs/biome format --write .",
-    "format:check": "bunx @biomejs/biome format .",
-    "lint": "bunx @biomejs/biome check --write --unsafe .",
-    "lint:check": "bunx @biomejs/biome check .",
-    "test": "vitest run __tests__/unit/",
-    "test:unit": "vitest run __tests__/unit/",
-    "test:integration": "echo 'Integration tests require scripts/run-integration-tests.sh - skipping'",
+    "format": "bunx @biomejs/biome format --write --config-path ./biome.json .",
+    "format:check": "bunx @biomejs/biome format --config-path ./biome.json .",
+    "lint": "bunx @biomejs/biome check --write --config-path ./biome.json .",
+    "lint:check": "bunx @biomejs/biome check --config-path ./biome.json .",
+    "test": "bun run test:real",
+    "test:unit": "echo 'unit-only sql tests removed; use bun run test:real'",
+    "test:integration": "vitest run __tests__/integration/",
     "test:integration:postgres": "bash scripts/run-integration-tests.sh --postgres",
     "test:migration": "vitest run __tests__/migration/",
     "test:migration:postgres": "vitest run __tests__/migration/",
+    "test:real": "bun run test:integration && bun run test:migration",
     "test:e2e:upgrade": "bash __tests__/migration/e2e/run-upgrade-test.sh",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -78,5 +100,16 @@
     "build": "bun run build.ts",
     "build:ts": "bun run build.ts"
   },
-  "gitHead": "bc6cac8d36845d7cbde51a64307c6a57c16378ad"
+  "gitHead": "255e37c0e4a76da0b776219db5ebb9dadf20e89f",
+  "eliza": {
+    "platforms": [
+      "browser",
+      "node"
+    ],
+    "runtime": "both",
+    "platformDetails": {
+      "browser": "Browser-compatible build available via exports.browser",
+      "node": "Node.js build available via exports.node"
+    }
+  }
 }

package/schema/agent.ts

@@ -0,0 +1,50 @@
+import type { MessageExample } from "@elizaos/core";
+import { sql } from "drizzle-orm";
+import { boolean, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+/**
+ * Represents a table for storing agent data.
+ *
+ * @type {Table}
+ */
+export const agentTable = pgTable("agents", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  enabled: boolean("enabled").default(true).notNull(),
+  server_id: uuid("server_id"),
+  createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+
+  updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
+
+  // Character
+  name: text("name").notNull(),
+  username: text("username"),
+  system: text("system").default(""),
+  bio: jsonb("bio").$type<string | string[]>().default(sql`'[]'::jsonb`),
+  messageExamples: jsonb("message_examples")
+    .$type<MessageExample[][]>()
+    .default(sql`'[]'::jsonb`)
+    .notNull(),
+  postExamples: jsonb("post_examples").$type<string[]>().default(sql`'[]'::jsonb`).notNull(),
+  topics: jsonb("topics").$type<string[]>().default(sql`'[]'::jsonb`).notNull(),
+  adjectives: jsonb("adjectives").$type<string[]>().default(sql`'[]'::jsonb`).notNull(),
+  knowledge: jsonb("knowledge")
+    .$type<(string | { path: string; shared?: boolean })[]>()
+    .default(sql`'[]'::jsonb`)
+    .notNull(),
+  plugins: jsonb("plugins").$type<string[]>().default(sql`'[]'::jsonb`).notNull(),
+  settings: jsonb("settings")
+    .$type<{
+      secrets?: { [key: string]: string | boolean | number };
+      [key: string]: string | boolean | number | Record<string, unknown> | undefined;
+    }>()
+    .default(sql`'{}'::jsonb`)
+    .notNull(),
+  style: jsonb("style")
+    .$type<{
+      all?: string[];
+      chat?: string[];
+      post?: string[];
+    }>()
+    .default(sql`'{}'::jsonb`)
+    .notNull(),
+});

package/schema/approvalRequests.ts

@@ -0,0 +1,57 @@
+import { sql } from "drizzle-orm";
+import { index, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Persistent backing store for the LifeOps human-in-the-loop approval queue.
+ *
+ * Owned by `apps/app-lifeops` (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.
+ *
+ * Migration safety: this table is additive. It is created on first boot via
+ * the runtime migrator when absent, and existing databases are unaffected.
+ *
+ * State, action, channel, resolved_by, resolution_reason, and resolved_at are
+ * intentionally text/timestamp without a CHECK constraint — the application
+ * layer is the single source of truth for the state machine and the closed
+ * action/channel enums (Commandment 7).
+ */
+export const approvalRequestTable = pgTable(
+  "approval_requests",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** Lifecycle state. See `ApprovalRequestState` in app-lifeops. */
+    state: text("state").notNull(),
+    /** Agent or service that enqueued the request. */
+    requestedBy: text("requested_by").notNull(),
+    /** Owner whose approval is required. */
+    subjectUserId: text("subject_user_id").notNull(),
+    /** Closed enum from `ApprovalAction`. */
+    action: text("action").notNull(),
+    /** Discriminated union from `ApprovalPayload`. */
+    payload: jsonb("payload").notNull(),
+    /** Closed enum from `ApprovalChannel`. */
+    channel: text("channel").notNull(),
+    /** Required justification for the request. */
+    reason: text("reason").notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    /** Null until the request leaves `pending`. */
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    /** Null until resolved; resolver identity. */
+    resolvedBy: text("resolved_by"),
+    /** Null until resolved; human-readable resolution note. */
+    resolutionReason: text("resolution_reason"),
+    /** Owning agent (cascade-deletes when the agent is removed). */
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
+  },
+  (table) => [
+    index("approval_requests_subject_state_idx").on(table.subjectUserId, table.state),
+    index("approval_requests_agent_state_idx").on(table.agentId, table.state),
+    index("approval_requests_state_expires_idx").on(table.state, table.expiresAt),
+  ]
+);

package/schema/authAuditEvent.ts

@@ -0,0 +1,29 @@
+import { bigint, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+
+/**
+ * Append-only audit row for every sensitive auth action.
+ *
+ * Rows are also mirrored to JSONL on disk so a wiped DB does not lose history.
+ * Token-shaped values in `metadata` MUST be redacted before insert by the
+ * caller.
+ */
+export const authAuditEventTable = pgTable(
+  "auth_audit_events",
+  {
+    id: text("id").primaryKey(),
+    ts: bigint("ts", { mode: "number" }).notNull(),
+    actorIdentityId: text("actor_identity_id"),
+    ip: text("ip"),
+    userAgent: text("user_agent"),
+    action: text("action").notNull(),
+    outcome: text("outcome").notNull(),
+    metadata: jsonb("metadata").$type<Record<string, string | number | boolean>>().notNull(),
+  },
+  (table) => [
+    index("auth_audit_events_action_idx").on(table.action),
+    index("auth_audit_events_ts_idx").on(table.ts),
+    index("auth_audit_events_actor_idx").on(table.actorIdentityId),
+  ]
+);
+
+export type AuthAuditOutcome = "success" | "failure";

package/schema/authBootstrapJti.ts

@@ -0,0 +1,18 @@
+import { bigint, index, pgTable, text } from "drizzle-orm/pg-core";
+
+/**
+ * Replay-defence set for bootstrap-token `jti` claims. A row exists for every
+ * bootstrap token successfully verified on this instance; subsequent
+ * presentations of the same `jti` must be rejected.
+ *
+ * Rows are kept until natural `exp` of the original token plus a buffer; the
+ * cleanup job lives in the auth-store.
+ */
+export const authBootstrapJtiSeenTable = pgTable(
+  "auth_bootstrap_jti_seen",
+  {
+    jti: text("jti").primaryKey(),
+    seenAt: bigint("seen_at", { mode: "number" }).notNull(),
+  },
+  (table) => [index("auth_bootstrap_jti_seen_at_idx").on(table.seenAt)]
+);

package/schema/authIdentity.ts

@@ -0,0 +1,35 @@
+import { sql } from "drizzle-orm";
+import { bigint, index, pgTable, text } from "drizzle-orm/pg-core";
+
+/**
+ * Auth identity row. One per real user / machine actor on this Eliza instance.
+ *
+ * `kind` distinguishes interactive ("owner") identities from non-interactive
+ * ("machine") identities used by long-lived bearer tokens. Exactly one of
+ * `passwordHash` or `cloudUserId` is expected to be populated for an owner
+ * (with possible owner-bindings extending login methods); machines have
+ * neither and are authenticated by the bearer token bound to their session.
+ */
+export const authIdentityTable = pgTable(
+  "auth_identities",
+  {
+    /** uuid v7 string. Stored as text so we don't have to pull a v7 generator into pg defaults. */
+    id: text("id").primaryKey(),
+    kind: text("kind").notNull(),
+    displayName: text("display_name").notNull(),
+    createdAt: bigint("created_at", { mode: "number" }).notNull(),
+    /** argon2id encoded password hash. Optional: cloud-only identities may not have one. */
+    passwordHash: text("password_hash"),
+    /** Linked Eliza Cloud user id when SSO is enabled. */
+    cloudUserId: text("cloud_user_id"),
+  },
+  (table) => [
+    index("auth_identities_kind_idx").on(table.kind),
+    index("auth_identities_cloud_user_idx").on(table.cloudUserId),
+  ]
+);
+
+export type AuthIdentityKind = "owner" | "machine";
+
+/** Default SQL `now() * 1000` to populate `created_at` when callers don't supply one. */
+export const authIdentityCreatedAtDefault = sql`(extract(epoch from now()) * 1000)::bigint`;

package/schema/authOwnerBinding.ts

@@ -0,0 +1,43 @@
+import { bigint, foreignKey, index, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+import { authIdentityTable } from "./authIdentity";
+
+/**
+ * Connector-owner binding. Lets an external connector account (Discord,
+ * Telegram, WeChat, Matrix) prove ownership of a local Eliza identity.
+ *
+ * Uniqueness is enforced on `(connector, external_id, instance_id)` so the same
+ * Discord account can own multiple Eliza instances (one binding per
+ * (connector, external) pair *per instance*) without cross-talk.
+ */
+export const authOwnerBindingTable = pgTable(
+  "auth_owner_bindings",
+  {
+    id: text("id").primaryKey(),
+    identityId: text("identity_id")
+      .notNull()
+      .references(() => authIdentityTable.id, { onDelete: "cascade" }),
+    connector: text("connector").notNull(),
+    externalId: text("external_id").notNull(),
+    displayHandle: text("display_handle").notNull(),
+    /** Stable per-instance id; populated from ELIZA_INSTANCE_ID or generated once at boot. */
+    instanceId: text("instance_id").notNull(),
+    verifiedAt: bigint("verified_at", { mode: "number" }).notNull(),
+    /** Hashed pairing code (sha256 hex) — never store the plaintext. */
+    pendingCodeHash: text("pending_code_hash"),
+    pendingExpiresAt: bigint("pending_expires_at", { mode: "number" }),
+  },
+  (table) => [
+    index("auth_owner_bindings_identity_idx").on(table.identityId),
+    index("auth_owner_bindings_connector_idx").on(table.connector),
+    uniqueIndex("auth_owner_bindings_connector_external_instance_uniq").on(
+      table.connector,
+      table.externalId,
+      table.instanceId
+    ),
+    foreignKey({
+      name: "fk_auth_owner_bindings_identity",
+      columns: [table.identityId],
+      foreignColumns: [authIdentityTable.id],
+    }).onDelete("cascade"),
+  ]
+);

package/schema/authOwnerLoginToken.ts

@@ -0,0 +1,50 @@
+import { bigint, foreignKey, index, pgTable, text } from "drizzle-orm/pg-core";
+import { authIdentityTable } from "./authIdentity";
+import { authOwnerBindingTable } from "./authOwnerBinding";
+
+/**
+ * Single-use DM-link login tokens for the connector-owner convenience flow.
+ *
+ * The user types `/eliza-pair` in their connector and asks Eliza to DM
+ * a login link. The DM contains a short-lived URL whose `?token=...` is
+ * the SHA-256 hash of a random UUID v7. The plaintext is sent only via the
+ * DM channel; the database stores only the hash so a DB read does not
+ * surrender unconsumed tokens.
+ *
+ * Tokens are consumed exactly once: the consume endpoint sets
+ * `consumed_at` and the row is preserved for audit. Rows older than
+ * `expires_at + 24h` are eligible for cleanup.
+ */
+export const authOwnerLoginTokenTable = pgTable(
+  "auth_owner_login_tokens",
+  {
+    /** SHA-256 hex of the plaintext token. Plaintext is never stored. */
+    tokenHash: text("token_hash").primaryKey(),
+    identityId: text("identity_id")
+      .notNull()
+      .references(() => authIdentityTable.id, { onDelete: "cascade" }),
+    /** Binding that issued this token. */
+    bindingId: text("binding_id")
+      .notNull()
+      .references(() => authOwnerBindingTable.id, { onDelete: "cascade" }),
+    issuedAt: bigint("issued_at", { mode: "number" }).notNull(),
+    expiresAt: bigint("expires_at", { mode: "number" }).notNull(),
+    /** Set on first successful consume. Null while the token is live. */
+    consumedAt: bigint("consumed_at", { mode: "number" }),
+  },
+  (table) => [
+    index("auth_owner_login_tokens_identity_idx").on(table.identityId),
+    index("auth_owner_login_tokens_binding_idx").on(table.bindingId),
+    index("auth_owner_login_tokens_expires_idx").on(table.expiresAt),
+    foreignKey({
+      name: "fk_auth_owner_login_tokens_identity",
+      columns: [table.identityId],
+      foreignColumns: [authIdentityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_auth_owner_login_tokens_binding",
+      columns: [table.bindingId],
+      foreignColumns: [authOwnerBindingTable.id],
+    }).onDelete("cascade"),
+  ]
+);

package/schema/authSession.ts

@@ -0,0 +1,44 @@
+import { bigint, boolean, foreignKey, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+import { authIdentityTable } from "./authIdentity";
+
+/**
+ * Active authenticated session.
+ *
+ * `id` is the opaque cookie value (256-bit hex) — server-side lookup, never JWT.
+ * `kind` is "browser" (sliding TTL, CSRF-bound) or "machine" (absolute TTL,
+ * scope-bearing bearer token).
+ *
+ * Browser sessions store a `csrfSecret` used to derive double-submit tokens.
+ * Machine sessions list explicit scopes; browser sessions get an empty list
+ * which the auth layer treats as "all scopes".
+ */
+export const authSessionTable = pgTable(
+  "auth_sessions",
+  {
+    id: text("id").primaryKey(),
+    identityId: text("identity_id")
+      .notNull()
+      .references(() => authIdentityTable.id, { onDelete: "cascade" }),
+    kind: text("kind").notNull(),
+    createdAt: bigint("created_at", { mode: "number" }).notNull(),
+    lastSeenAt: bigint("last_seen_at", { mode: "number" }).notNull(),
+    expiresAt: bigint("expires_at", { mode: "number" }).notNull(),
+    rememberDevice: boolean("remember_device").notNull().default(false),
+    csrfSecret: text("csrf_secret").notNull(),
+    ip: text("ip"),
+    userAgent: text("user_agent"),
+    scopes: jsonb("scopes").$type<string[]>().notNull(),
+    revokedAt: bigint("revoked_at", { mode: "number" }),
+  },
+  (table) => [
+    index("auth_sessions_identity_idx").on(table.identityId),
+    index("auth_sessions_expires_idx").on(table.expiresAt),
+    foreignKey({
+      name: "fk_auth_sessions_identity",
+      columns: [table.identityId],
+      foreignColumns: [authIdentityTable.id],
+    }).onDelete("cascade"),
+  ]
+);
+
+export type AuthSessionKind = "browser" | "machine";

package/schema/cache.ts

@@ -0,0 +1,22 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, primaryKey, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents a PostgreSQL table for caching data.
+ *
+ * @type {pgTable}
+ */
+export const cacheTable = pgTable(
+  "cache",
+  {
+    key: text("key").notNull(),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb("value").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+  },
+  (table) => [primaryKey({ columns: [table.key, table.agentId] })]
+);

package/schema/channel.ts

@@ -0,0 +1,19 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { messageServerTable } from "./messageServer";
+
+export const channelTable = pgTable("channels", {
+  id: text("id").primaryKey(), // UUID stored as text
+  messageServerId: uuid("message_server_id")
+    .notNull()
+    .references(() => messageServerTable.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  type: text("type").notNull(), // Store ChannelType enum values as text
+  sourceType: text("source_type"),
+  sourceId: text("source_id"),
+  topic: text("topic"),
+  metadata: jsonb("metadata"),
+  // server_id is added dynamically by RLS setup
+  createdAt: timestamp("created_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+});

package/schema/channelParticipant.ts

@@ -0,0 +1,13 @@
+import { pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+import { channelTable } from "./channel";
+
+export const channelParticipantsTable = pgTable(
+  "channel_participants",
+  {
+    channelId: text("channel_id")
+      .notNull()
+      .references(() => channelTable.id, { onDelete: "cascade" }),
+    entityId: text("entity_id").notNull(), // Entity UUID (can be an agentId or a dedicated central user ID)
+  },
+  (table) => [primaryKey({ columns: [table.channelId, table.entityId] })]
+);

package/schema/component.ts

@@ -0,0 +1,37 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { entityTable } from "./entity";
+import { roomTable } from "./room";
+import { worldTable } from "./world";
+
+/**
+ * Represents a component table in the database.
+ */
+export const componentTable = pgTable("components", {
+  id: uuid("id").primaryKey().default(sql`gen_random_uuid()`).notNull(),
+
+  // Foreign keys
+  entityId: uuid("entity_id")
+    .references(() => entityTable.id, { onDelete: "cascade" })
+    .notNull(),
+  agentId: uuid("agent_id")
+    .references(() => agentTable.id, { onDelete: "cascade" })
+    .notNull(),
+  roomId: uuid("room_id")
+    .references(() => roomTable.id, { onDelete: "cascade" })
+    .notNull(),
+  worldId: uuid("world_id").references(() => worldTable.id, {
+    onDelete: "cascade",
+  }),
+  sourceEntityId: uuid("source_entity_id").references(() => entityTable.id, {
+    onDelete: "cascade",
+  }),
+
+  // Data
+  type: text("type").notNull(),
+  data: jsonb("data").default(sql`'{}'::jsonb`),
+
+  // Timestamps
+  createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+});