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

package/schema/embedding.ts

@@ -0,0 +1,73 @@
+import { relations, sql } from "drizzle-orm";
+import { check, foreignKey, index, pgTable, timestamp, uuid, vector } from "drizzle-orm/pg-core";
+import { memoryTable } from "./memory";
+
+export const VECTOR_DIMS = {
+  SMALL: 384,
+  MEDIUM: 512,
+  LARGE: 768,
+  XL: 1024,
+  XXL: 1536,
+  XXXL: 3072,
+} as const;
+
+export const DIMENSION_MAP = {
+  [VECTOR_DIMS.SMALL]: "dim384",
+  [VECTOR_DIMS.MEDIUM]: "dim512",
+  [VECTOR_DIMS.LARGE]: "dim768",
+  [VECTOR_DIMS.XL]: "dim1024",
+  [VECTOR_DIMS.XXL]: "dim1536",
+  [VECTOR_DIMS.XXXL]: "dim3072",
+} as const;
+
+/**
+ * Definition of the embeddings table in the database.
+ * Contains columns for ID, Memory ID, Creation Timestamp, and multiple vector dimensions.
+ */
+export const embeddingTable = pgTable(
+  "embeddings",
+  {
+    id: uuid("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid("memory_id").references(() => memoryTable.id, {
+      onDelete: "cascade",
+    }),
+    createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+    dim384: vector("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
+    dim512: vector("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
+    dim768: vector("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
+    dim1024: vector("dim_1024", { dimensions: VECTOR_DIMS.XL }),
+    dim1536: vector("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
+    dim3072: vector("dim_3072", { dimensions: VECTOR_DIMS.XXXL }),
+  },
+  (table) => [
+    check("embedding_source_check", sql`"memory_id" IS NOT NULL`),
+    index("idx_embedding_memory").on(table.memoryId),
+    foreignKey({
+      name: "fk_embedding_memory",
+      columns: [table.memoryId],
+      foreignColumns: [memoryTable.id],
+    }).onDelete("cascade"),
+  ]
+);
+
+/**
+ * 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";
+
+/**
+ * Retrieve the type of a specific column in the EmbeddingTable based on the EmbeddingDimensionColumn key.
+ */
+export type EmbeddingTableColumn = (typeof embeddingTable._.columns)[EmbeddingDimensionColumn];
+
+// Relations - defined here to avoid circular dependency with memory.ts
+export const memoryRelations = relations(memoryTable, ({ one }) => ({
+  embedding: one(embeddingTable),
+}));

package/schema/entity.ts

@@ -0,0 +1,28 @@
+import type { Metadata } from "@elizaos/core";
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, unique, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents an entity table in the database.
+ * Includes columns for id, agentId, createdAt, names, and metadata.
+ */
+export const entityTable = pgTable(
+  "entities",
+  {
+    id: uuid("id").notNull().primaryKey(),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, {
+        onDelete: "cascade",
+      }),
+    createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+    names: text("names").array().default(sql`'{}'::text[]`).notNull(),
+    metadata: jsonb("metadata").$type<Metadata>().default(sql`'{}'::jsonb`).notNull(),
+  },
+  (table) => {
+    return {
+      idAgentIdUnique: unique("id_agent_id_unique").on(table.id, table.agentId),
+    };
+  }
+);

package/schema/entityIdentity.ts

@@ -0,0 +1,142 @@
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  foreignKey,
+  index,
+  jsonb,
+  pgTable,
+  real,
+  text,
+  timestamp,
+  unique,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { entityTable } from "./entity";
+
+/**
+ * Strengthened (platform, handle) claim attached to an entity. Re-observations
+ * of the same pair bump confidence and append to evidence_message_ids rather
+ * than producing duplicate rows.
+ */
+export const entityIdentityTable = pgTable(
+  "entity_identities",
+  {
+    id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+    entityId: uuid("entity_id")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    platform: text("platform").notNull(),
+    handle: text("handle").notNull(),
+    verified: boolean("verified").notNull().default(false),
+    confidence: real("confidence").notNull().default(0),
+    source: text("source"),
+    firstSeen: timestamp("first_seen", { withTimezone: true }).notNull().default(sql`now()`),
+    lastSeen: timestamp("last_seen", { withTimezone: true }).notNull().default(sql`now()`),
+    evidenceMessageIds: jsonb("evidence_message_ids").$type<string[]>(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().default(sql`now()`),
+  },
+  (table) => [
+    index("idx_entity_identities_entity").on(table.entityId),
+    index("idx_entity_identities_platform_handle").on(table.platform, table.handle),
+    unique("unique_entity_identity").on(
+      table.entityId,
+      table.platform,
+      table.handle,
+      table.agentId
+    ),
+    foreignKey({
+      name: "fk_entity_identities_entity",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_entity_identities_agent",
+      columns: [table.agentId],
+      foreignColumns: [agentTable.id],
+    }).onDelete("cascade"),
+  ]
+);
+
+export const entityMergeCandidateTable = pgTable(
+  "entity_merge_candidates",
+  {
+    id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    entityA: uuid("entity_a")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    entityB: uuid("entity_b")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    confidence: real("confidence").notNull().default(0),
+    evidence: jsonb("evidence"),
+    status: text("status").notNull().default("pending"),
+    proposedAt: timestamp("proposed_at", { withTimezone: true }).notNull().default(sql`now()`),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+  },
+  (table) => [
+    index("idx_entity_merge_candidates_status").on(table.status),
+    index("idx_entity_merge_candidates_pair").on(table.entityA, table.entityB),
+    foreignKey({
+      name: "fk_entity_merge_candidates_a",
+      columns: [table.entityA],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_entity_merge_candidates_b",
+      columns: [table.entityB],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_entity_merge_candidates_agent",
+      columns: [table.agentId],
+      foreignColumns: [agentTable.id],
+    }).onDelete("cascade"),
+  ]
+);
+
+/**
+ * Pending fact refinement proposals (contradictions / merges) surfaced from
+ * the FactRefinementEvaluator. The Facts tab in the UI lets users accept
+ * or reject these.
+ */
+export const factCandidateTable = pgTable(
+  "fact_candidates",
+  {
+    id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    entityId: uuid("entity_id")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    kind: text("kind").notNull(),
+    existingFactId: uuid("existing_fact_id"),
+    proposedText: text("proposed_text").notNull(),
+    confidence: real("confidence").notNull().default(0),
+    evidence: jsonb("evidence"),
+    status: text("status").notNull().default("pending"),
+    proposedAt: timestamp("proposed_at", { withTimezone: true }).notNull().default(sql`now()`),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+  },
+  (table) => [
+    index("idx_fact_candidates_status").on(table.status),
+    index("idx_fact_candidates_entity").on(table.entityId),
+    foreignKey({
+      name: "fk_fact_candidates_entity",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_fact_candidates_agent",
+      columns: [table.agentId],
+      foreignColumns: [agentTable.id],
+    }).onDelete("cascade"),
+  ]
+);

package/schema/index.ts

@@ -0,0 +1,41 @@
+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 { 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";

package/schema/log.ts

@@ -0,0 +1,38 @@
+import { sql } from "drizzle-orm";
+import { foreignKey, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { entityTable } from "./entity";
+import { roomTable } from "./room";
+
+/**
+ * Represents a PostgreSQL table for storing logs.
+ *
+ * @type {Table}
+ */
+
+export const logTable = pgTable(
+  "logs",
+  {
+    id: uuid("id").defaultRandom().notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    entityId: uuid("entity_id")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    body: jsonb("body").notNull(),
+    type: text("type").notNull(),
+    roomId: uuid("room_id")
+      .notNull()
+      .references(() => roomTable.id, { onDelete: "cascade" }),
+  },
+  (table) => [
+    foreignKey({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+  ]
+);

package/schema/longTermMemories.ts

@@ -0,0 +1,27 @@
+import { sql } from "drizzle-orm";
+import { index, integer, jsonb, pgTable, real, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const longTermMemories = pgTable(
+  "long_term_memories",
+  {
+    id: uuid("id").primaryKey().notNull(),
+    agentId: uuid("agent_id").notNull(),
+    entityId: uuid("entity_id").notNull(),
+    category: text("category").notNull(),
+    content: text("content").notNull(),
+    metadata: jsonb("metadata"),
+    embedding: real("embedding").array(),
+    confidence: real("confidence").default(1),
+    source: text("source"),
+    createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at").default(sql`now()`).notNull(),
+    lastAccessedAt: timestamp("last_accessed_at"),
+    accessCount: integer("access_count").default(0),
+  },
+  (table) => [
+    index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
+    index("long_term_memories_category_idx").on(table.category),
+    index("long_term_memories_confidence_idx").on(table.confidence),
+    index("long_term_memories_created_at_idx").on(table.createdAt),
+  ]
+);

package/schema/memory.ts

@@ -0,0 +1,103 @@
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  check,
+  foreignKey,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { entityTable } from "./entity";
+import { roomTable } from "./room";
+
+/**
+ * Definition of the memory table in the database.
+ *
+ * @param {string} tableName - The name of the table.
+ * @param {object} columns - An object containing the column definitions.
+ * @param {function} indexes - A function that defines the indexes for the table.
+ * @returns {object} - The memory table object.
+ */
+export const memoryTable = pgTable(
+  "memories",
+  {
+    id: uuid("id").primaryKey().notNull(),
+    type: text("type").notNull(),
+    createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+    content: jsonb("content").notNull(),
+    entityId: uuid("entity_id").references(() => entityTable.id, {
+      onDelete: "cascade",
+    }),
+    agentId: uuid("agent_id")
+      .references(() => agentTable.id, {
+        onDelete: "cascade",
+      })
+      .notNull(),
+    roomId: uuid("room_id").references(() => roomTable.id, {
+      onDelete: "cascade",
+    }),
+    worldId: uuid("world_id"),
+    // .references(() => worldTable.id, {
+    //   onDelete: 'set null',
+    // }),
+    unique: boolean("unique").default(true).notNull(),
+    metadata: jsonb("metadata").default({}).notNull(),
+  },
+  (table) => [
+    index("idx_memories_type_room").on(table.type, table.roomId),
+    index("idx_memories_world_id").on(table.worldId),
+    foreignKey({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_agent",
+      columns: [table.agentId],
+      foreignColumns: [agentTable.id],
+    }).onDelete("cascade"),
+    // foreignKey({
+    //   name: 'fk_world',
+    //   columns: [table.worldId],
+    //   foreignColumns: [worldTable.id],
+    // }).onDelete('set null'),
+    index("idx_memories_metadata_type").on(sql`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql`((metadata->>'documentId'))`),
+    index("idx_fragments_order").on(
+      sql`((metadata->>'documentId'))`,
+      sql`((metadata->>'position'))`
+    ),
+    check(
+      "fragment_metadata_check",
+      sql`
+            CASE 
+                WHEN metadata->>'type' = 'fragment' THEN
+                    metadata ? 'documentId' AND 
+                    metadata ? 'position'
+                ELSE true
+            END
+        `
+    ),
+    check(
+      "document_metadata_check",
+      sql`
+            CASE 
+                WHEN metadata->>'type' = 'document' THEN
+                    metadata ? 'timestamp'
+                ELSE true
+            END
+        `
+    ),
+  ]
+);
+
+// Relations are defined in embedding.ts to avoid circular dependency

package/schema/memoryAccessLogs.ts

@@ -0,0 +1,19 @@
+import { sql } from "drizzle-orm";
+import { index, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const memoryAccessLogs = pgTable(
+  "memory_access_logs",
+  {
+    id: uuid("id").primaryKey().notNull(),
+    memoryId: uuid("memory_id").notNull(),
+    memoryType: text("memory_type").notNull(),
+    agentId: uuid("agent_id").notNull(),
+    accessType: text("access_type").notNull(),
+    accessedAt: timestamp("accessed_at").default(sql`now()`).notNull(),
+  },
+  (table) => [
+    index("memory_access_logs_memory_id_idx").on(table.memoryId),
+    index("memory_access_logs_agent_id_idx").on(table.agentId),
+    index("memory_access_logs_accessed_at_idx").on(table.accessedAt),
+  ]
+);

package/schema/message.ts

@@ -0,0 +1,24 @@
+import { sql } from "drizzle-orm";
+import { type AnyPgColumn, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { channelTable } from "./channel";
+
+export const messageTable = pgTable("central_messages", {
+  id: text("id").primaryKey(), // UUID stored as text
+  channelId: text("channel_id")
+    .notNull()
+    .references(() => channelTable.id, { onDelete: "cascade" }),
+  authorId: text("author_id").notNull(),
+  content: text("content").notNull(),
+  rawMessage: jsonb("raw_message"),
+  inReplyToRootMessageId: text("in_reply_to_root_message_id").references(
+    (): AnyPgColumn => messageTable.id,
+    {
+      onDelete: "set null",
+    }
+  ),
+  sourceType: text("source_type"),
+  sourceId: text("source_id"),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+});

package/schema/messageServer.ts

@@ -0,0 +1,12 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const messageServerTable = pgTable("message_servers", {
+  id: uuid("id").primaryKey(),
+  name: text("name").notNull(),
+  sourceType: text("source_type").notNull(),
+  sourceId: text("source_id"),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).default(sql`CURRENT_TIMESTAMP`).notNull(),
+});

package/schema/messageServerAgent.ts

@@ -0,0 +1,16 @@
+import { pgTable, primaryKey, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { messageServerTable } from "./messageServer";
+
+export const messageServerAgentsTable = pgTable(
+  "message_server_agents",
+  {
+    messageServerId: uuid("message_server_id")
+      .notNull()
+      .references(() => messageServerTable.id, { onDelete: "cascade" }),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+  },
+  (table) => [primaryKey({ columns: [table.messageServerId, table.agentId] })]
+);

package/schema/pairingAllowlist.ts

@@ -0,0 +1,36 @@
+import { sql } from "drizzle-orm";
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents the allowlist of approved senders for each channel.
+ * Senders in this list are permitted to send DMs to the bot.
+ */
+export const pairingAllowlistTable = pgTable(
+  "pairing_allowlist",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** The messaging channel (telegram, discord, whatsapp, etc.) */
+    channel: text("channel").notNull(),
+    /** Approved sender identifier */
+    senderId: text("sender_id").notNull(),
+    /** When the entry was added */
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    /** Optional metadata about the approved sender */
+    metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+    /** Agent ID this allowlist belongs to */
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+  },
+  (table) => [
+    // Index for looking up allowlist by channel and agent
+    index("pairing_allowlist_channel_agent_idx").on(table.channel, table.agentId),
+    // Unique constraint to prevent duplicate entries
+    uniqueIndex("pairing_allowlist_sender_channel_agent_idx").on(
+      table.senderId,
+      table.channel,
+      table.agentId
+    ),
+  ]
+);

package/schema/pairingRequest.ts

@@ -0,0 +1,46 @@
+import { sql } from "drizzle-orm";
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents pending pairing requests from users trying to access the bot via DM.
+ * Requests are stored temporarily until approved or expired.
+ */
+export const pairingRequestTable = pgTable(
+  "pairing_requests",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** The messaging channel (telegram, discord, whatsapp, etc.) */
+    channel: text("channel").notNull(),
+    /** User identifier on the channel (userId, phoneNumber, etc.) */
+    senderId: text("sender_id").notNull(),
+    /** Human-friendly pairing code */
+    code: text("code").notNull(),
+    /** When the request was created */
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    /** When the request was last seen/updated */
+    lastSeenAt: timestamp("last_seen_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    /** Optional metadata about the requester */
+    metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+    /** Agent ID that received this request */
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+  },
+  (table) => [
+    // Index for looking up requests by channel and agent
+    index("pairing_requests_channel_agent_idx").on(table.channel, table.agentId),
+    // Unique constraint on code per channel/agent to prevent duplicates
+    uniqueIndex("pairing_requests_code_channel_agent_idx").on(
+      table.code,
+      table.channel,
+      table.agentId
+    ),
+    // Unique constraint on sender per channel/agent (one request per user)
+    uniqueIndex("pairing_requests_sender_channel_agent_idx").on(
+      table.senderId,
+      table.channel,
+      table.agentId
+    ),
+  ]
+);

package/schema/participant.ts

@@ -0,0 +1,43 @@
+import { sql } from "drizzle-orm";
+import { foreignKey, index, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { entityTable } from "./entity";
+import { roomTable } from "./room";
+
+/**
+ * Defines the schema for the "participants" table in the database.
+ *
+ * @type {import('knex').TableBuilder}
+ */
+export const participantTable = pgTable(
+  "participants",
+  {
+    id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    entityId: uuid("entity_id").references(() => entityTable.id, {
+      onDelete: "cascade",
+    }),
+    roomId: uuid("room_id").references(() => roomTable.id, {
+      onDelete: "cascade",
+    }),
+    agentId: uuid("agent_id").references(() => agentTable.id, {
+      onDelete: "cascade",
+    }),
+    roomState: text("room_state"),
+  },
+  (table) => [
+    // unique("participants_user_room_agent_unique").on(table.entityId, table.roomId, table.agentId),
+    index("idx_participants_user").on(table.entityId),
+    index("idx_participants_room").on(table.roomId),
+    foreignKey({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+  ]
+);