@elizaos/plugin-sql 1.0.0-beta.44 → 1.0.0-beta.46

package/dist/index.js

@@ -1,27 +1,1223 @@
-import{a as x,b as ge,c as ye}from"./chunk-K7ZVMPCJ.js";import*as ke from"node:os";import{logger as Le}from"@elizaos/core";import{logger as Ce}from"@elizaos/core";import{drizzle as Bt}from"drizzle-orm/pglite";import{DatabaseAdapter as _t,logger as o,stringToUuid as Pt}from"@elizaos/core";import{and as w,cosineDistance as Nt,count as Mt,desc as z,eq as n,gte as xe,inArray as D,lte as St,or as vt,sql as M,not as qt}from"drizzle-orm";import{v4 as O}from"uuid";import{sql as Ee}from"drizzle-orm";import{check as rt,foreignKey as nt,index as it,pgTable as at,uuid as Te,vector as F}from"drizzle-orm/pg-core";import{VECTOR_DIMS as v}from"@elizaos/core";import{relations as Ye,sql as k}from"drizzle-orm";import{boolean as Qe,check as De,foreignKey as V,index as G,jsonb as Ue,pgTable as et,text as tt,uuid as H}from"drizzle-orm/pg-core";import{sql as C}from"drizzle-orm";import{boolean as Oe,jsonb as $,pgTable as Fe,text as ne,unique as je,uuid as ze}from"drizzle-orm/pg-core";import{customType as he}from"drizzle-orm/pg-core";var kt=he({dataType(){return"jsonb"},toDriver(m){return JSON.stringify(m)},fromDriver(m){return JSON.stringify(m)}}),T=he({dataType(){return"timestamptz"},toDriver(m){return new Date(m).toISOString()},fromDriver(m){return new Date(m).getTime()}});var b=Fe("agents",{id:ze("id").primaryKey().defaultRandom(),enabled:Oe("enabled").default(!0).notNull(),createdAt:T("createdAt").default(C`now()`).notNull(),updatedAt:T("updatedAt").default(C`now()`).notNull(),name:ne("name"),username:ne("username"),system:ne("system"),bio:$("bio").$type().notNull(),messageExamples:$("message_examples").$type().default(C`'[]'::jsonb`),postExamples:$("post_examples").$type().default(C`'[]'::jsonb`),topics:$("topics").$type().default(C`'[]'::jsonb`),adjectives:$("adjectives").$type().default(C`'[]'::jsonb`),knowledge:$("knowledge").$type().default(C`'[]'::jsonb`),plugins:$("plugins").$type().default(C`'[]'::jsonb`),settings:$("settings").$type().default(C`'{}'::jsonb`),style:$("style").$type().default(C`'{}'::jsonb`)},m=>({nameUnique:je("name_unique").on(m.name)}));import{sql as ie}from"drizzle-orm";import{jsonb as Je,pgTable as We,text as Ke,unique as Ge,uuid as Ie}from"drizzle-orm/pg-core";var h=We("entities",{id:Ie("id").notNull().primaryKey(),agentId:Ie("agentId").notNull().references(()=>b.id,{onDelete:"cascade"}),createdAt:T("createdAt").default(ie`now()`).notNull(),names:Ke("names").array().default(ie`'{}'::text[]`),metadata:Je("metadata").default(ie`'{}'::jsonb`)},m=>({idAgentIdUnique:Ge("id_agent_id_unique").on(m.id,m.agentId)}));import{sql as we}from"drizzle-orm";import{jsonb as Ve,pgTable as Ze,text as K,uuid as ae}from"drizzle-orm/pg-core";import{sql as be}from"drizzle-orm";import{jsonb as He,pgTable as Xe,text as fe,uuid as pe}from"drizzle-orm/pg-core";var E=Xe("worlds",{id:pe("id").notNull().primaryKey().default(be`gen_random_uuid()`),agentId:pe("agentId").notNull().references(()=>b.id,{onDelete:"cascade"}),name:fe("name").notNull(),metadata:He("metadata"),serverId:fe("serverId").notNull(),createdAt:T("createdAt").default(be`now()`).notNull()});var c=Ze("rooms",{id:ae("id").notNull().primaryKey().default(we`gen_random_uuid()`),agentId:ae("agentId").references(()=>b.id,{onDelete:"cascade"}),source:K("source").notNull(),type:K("type").notNull(),serverId:K("serverId"),worldId:ae("worldId").references(()=>E.id,{onDelete:"cascade"}),name:K("name"),metadata:Ve("metadata"),channelId:K("channelId"),createdAt:T("createdAt").default(we`now()`).notNull()});var a=et("memories",{id:H("id").primaryKey().notNull(),type:tt("type").notNull(),createdAt:T("createdAt").default(k`now()`).notNull(),content:Ue("content").notNull(),entityId:H("entityId").references(()=>h.id,{onDelete:"cascade"}),agentId:H("agentId").references(()=>b.id,{onDelete:"cascade"}),roomId:H("roomId").references(()=>c.id,{onDelete:"cascade"}),worldId:H("worldId").references(()=>E.id,{onDelete:"set null"}),unique:Qe("unique").default(!0).notNull(),metadata:Ue("metadata").default({}).notNull()},m=>[G("idx_memories_type_room").on(m.type,m.roomId),G("idx_memories_world_id").on(m.worldId),V({name:"fk_room",columns:[m.roomId],foreignColumns:[c.id]}).onDelete("cascade"),V({name:"fk_user",columns:[m.entityId],foreignColumns:[h.id]}).onDelete("cascade"),V({name:"fk_agent",columns:[m.agentId],foreignColumns:[b.id]}).onDelete("cascade"),V({name:"fk_world",columns:[m.worldId],foreignColumns:[E.id]}).onDelete("set null"),G("idx_memories_metadata_type").on(k`((metadata->>'type'))`),G("idx_memories_document_id").on(k`((metadata->>'documentId'))`),G("idx_fragments_order").on(k`((metadata->>'documentId'))`,k`((metadata->>'position'))`),De("fragment_metadata_check",k`
+import {
+  PGliteClientManager,
+  PostgresConnectionManager,
+  __name
+} from "./chunk-EYE2J2N6.js";
+
+// src/index.ts
+import * as os from "node:os";
+import { logger as logger4 } from "@elizaos/core";
+
+// src/pglite/adapter.ts
+import { logger as logger2 } from "@elizaos/core";
+import { drizzle } from "drizzle-orm/pglite";
+
+// src/base.ts
+import {
+  DatabaseAdapter,
+  logger,
+  stringToUuid
+} from "@elizaos/core";
+import {
+  and,
+  cosineDistance,
+  count,
+  desc,
+  eq,
+  gte,
+  inArray,
+  lte,
+  or,
+  sql as sql12,
+  not
+} from "drizzle-orm";
+import { v4 } from "uuid";
+
+// src/schema/embedding.ts
+import { sql as sql6 } from "drizzle-orm";
+import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable6, uuid as uuid6, vector as vector2 } from "drizzle-orm/pg-core";
+import { VECTOR_DIMS } from "@elizaos/core";
+
+// src/schema/memory.ts
+import { relations, sql as sql5 } from "drizzle-orm";
+import {
+  boolean as boolean2,
+  check,
+  foreignKey,
+  index,
+  jsonb as jsonb5,
+  pgTable as pgTable5,
+  text as text5,
+  uuid as uuid5
+} from "drizzle-orm/pg-core";
+
+// src/schema/agent.ts
+import { sql } from "drizzle-orm";
+import { boolean, jsonb, pgTable, text, unique, uuid } from "drizzle-orm/pg-core";
+
+// src/schema/types.ts
+import { customType } from "drizzle-orm/pg-core";
+var stringJsonb = customType({
+  dataType() {
+    return "jsonb";
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  },
+  fromDriver(value) {
+    return JSON.stringify(value);
+  }
+});
+var numberTimestamp = customType({
+  dataType() {
+    return "timestamptz";
+  },
+  toDriver(value) {
+    return new Date(value).toISOString();
+  },
+  fromDriver(value) {
+    return new Date(value).getTime();
+  }
+});
+
+// src/schema/agent.ts
+var agentTable = pgTable(
+  "agents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    enabled: boolean("enabled").default(true).notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql`now()`).notNull(),
+    updatedAt: numberTimestamp("updatedAt").default(sql`now()`).notNull(),
+    // Character
+    name: text("name"),
+    username: text("username"),
+    system: text("system"),
+    bio: jsonb("bio").$type().notNull(),
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`)
+  },
+  (table) => {
+    return {
+      nameUnique: unique("name_unique").on(table.name)
+    };
+  }
+);
+
+// src/schema/entity.ts
+import { sql as sql2 } from "drizzle-orm";
+import { jsonb as jsonb2, pgTable as pgTable2, text as text2, unique as unique2, uuid as uuid2 } from "drizzle-orm/pg-core";
+var entityTable = pgTable2(
+  "entities",
+  {
+    id: uuid2("id").notNull().primaryKey(),
+    agentId: uuid2("agentId").notNull().references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    createdAt: numberTimestamp("createdAt").default(sql2`now()`).notNull(),
+    names: text2("names").array().default(sql2`'{}'::text[]`),
+    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`)
+  },
+  (table) => {
+    return {
+      idAgentIdUnique: unique2("id_agent_id_unique").on(table.id, table.agentId)
+    };
+  }
+);
+
+// src/schema/room.ts
+import { sql as sql4 } from "drizzle-orm";
+import { jsonb as jsonb4, pgTable as pgTable4, text as text4, uuid as uuid4 } from "drizzle-orm/pg-core";
+
+// src/schema/world.ts
+import { sql as sql3 } from "drizzle-orm";
+import { jsonb as jsonb3, pgTable as pgTable3, text as text3, uuid as uuid3 } from "drizzle-orm/pg-core";
+var worldTable = pgTable3("worlds", {
+  id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
+  agentId: uuid3("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text3("name").notNull(),
+  metadata: jsonb3("metadata"),
+  serverId: text3("serverId").notNull(),
+  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
+});
+
+// src/schema/room.ts
+var roomTable = pgTable4("rooms", {
+  id: uuid4("id").notNull().primaryKey().default(sql4`gen_random_uuid()`),
+  agentId: uuid4("agentId").references(() => agentTable.id, {
+    onDelete: "cascade"
+  }),
+  source: text4("source").notNull(),
+  type: text4("type").notNull(),
+  serverId: text4("serverId"),
+  worldId: uuid4("worldId").references(() => worldTable.id, {
+    onDelete: "cascade"
+  }),
+  name: text4("name"),
+  metadata: jsonb4("metadata"),
+  channelId: text4("channelId"),
+  createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull()
+});
+
+// src/schema/memory.ts
+var memoryTable = pgTable5(
+  "memories",
+  {
+    id: uuid5("id").primaryKey().notNull(),
+    type: text5("type").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql5`now()`).notNull(),
+    content: jsonb5("content").notNull(),
+    entityId: uuid5("entityId").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid5("agentId").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    roomId: uuid5("roomId").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    worldId: uuid5("worldId").references(() => worldTable.id, {
+      onDelete: "set null"
+    }),
+    unique: boolean2("unique").default(true).notNull(),
+    metadata: jsonb5("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(sql5`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql5`((metadata->>'documentId'))`),
+    index("idx_fragments_order").on(
+      sql5`((metadata->>'documentId'))`,
+      sql5`((metadata->>'position'))`
+    ),
+    check(
+      "fragment_metadata_check",
+      sql5`
             CASE 
                 WHEN metadata->>'type' = 'fragment' THEN
                     metadata ? 'documentId' AND 
                     metadata ? 'position'
                 ELSE true
             END
-        `),De("document_metadata_check",k`
+        `
+    ),
+    check(
+      "document_metadata_check",
+      sql5`
             CASE 
                 WHEN metadata->>'type' = 'document' THEN
                     metadata ? 'timestamp'
                 ELSE true
             END
-        `)]),br=Ye(a,({one:m})=>({embedding:m(l)}));var L={[v.SMALL]:"dim384",[v.MEDIUM]:"dim512",[v.LARGE]:"dim768",[v.XL]:"dim1024",[v.XXL]:"dim1536",[v.XXXL]:"dim3072"},l=at("embeddings",{id:Te("id").primaryKey().defaultRandom().notNull(),memoryId:Te("memory_id").references(()=>a.id),createdAt:T("created_at").default(Ee`now()`).notNull(),dim384:F("dim_384",{dimensions:v.SMALL}),dim512:F("dim_512",{dimensions:v.MEDIUM}),dim768:F("dim_768",{dimensions:v.LARGE}),dim1024:F("dim_1024",{dimensions:v.XL}),dim1536:F("dim_1536",{dimensions:v.XXL}),dim3072:F("dim_3072",{dimensions:v.XXXL})},m=>[rt("embedding_source_check",Ee`"memory_id" IS NOT NULL`),it("idx_embedding_memory").on(m.memoryId),nt({name:"fk_embedding_memory",columns:[m.memoryId],foreignColumns:[a.id]}).onDelete("cascade")]);import{sql as Ae}from"drizzle-orm";import{jsonb as ot,pgTable as st,text as dt,unique as mt,uuid as _e}from"drizzle-orm/pg-core";var S=st("cache",{id:_e("id").notNull().primaryKey().default(Ae`gen_random_uuid()`),key:dt("key").notNull(),agentId:_e("agentId").notNull().references(()=>b.id,{onDelete:"cascade"}),value:ot("value").notNull(),createdAt:T("createdAt").default(Ae`now()`).notNull(),expiresAt:T("expiresAt")},m=>[mt("cache_key_agent_unique").on(m.key,m.agentId)]);import{sql as Pe}from"drizzle-orm";import{jsonb as ct,pgTable as lt,text as ut,uuid as j}from"drizzle-orm/pg-core";var f=lt("components",{id:j("id").primaryKey().defaultRandom(),entityId:j("entityId").notNull().references(()=>h.id,{onDelete:"cascade"}),agentId:j("agentId").notNull().references(()=>b.id,{onDelete:"cascade"}),roomId:j("roomId").notNull().references(()=>c.id,{onDelete:"cascade"}),worldId:j("worldId").references(()=>E.id,{onDelete:"cascade"}),sourceEntityId:j("sourceEntityId").references(()=>h.id,{onDelete:"cascade"}),type:ut("type").notNull(),data:ct("data").default(Pe`'{}'::jsonb`),createdAt:T("createdAt").default(Pe`now()`).notNull()});import{sql as gt}from"drizzle-orm";import{foreignKey as Ne,jsonb as yt,pgTable as ht,text as It,uuid as oe}from"drizzle-orm/pg-core";var N=ht("logs",{id:oe("id").defaultRandom().notNull(),createdAt:T("createdAt").default(gt`now()`).notNull(),entityId:oe("entityId").notNull().references(()=>h.id),body:yt("body").notNull(),type:It("type").notNull(),roomId:oe("roomId").notNull().references(()=>c.id)},m=>[Ne({name:"fk_room",columns:[m.roomId],foreignColumns:[c.id]}).onDelete("cascade"),Ne({name:"fk_user",columns:[m.entityId],foreignColumns:[h.id]}).onDelete("cascade")]);import{sql as Me}from"drizzle-orm";import{foreignKey as Se,index as ve,pgTable as bt,text as ft,uuid as Z}from"drizzle-orm/pg-core";var u=bt("participants",{id:Z("id").notNull().primaryKey().default(Me`gen_random_uuid()`),createdAt:T("createdAt").default(Me`now()`).notNull(),entityId:Z("entityId").references(()=>h.id,{onDelete:"cascade"}),roomId:Z("roomId").references(()=>c.id,{onDelete:"cascade"}),agentId:Z("agentId").references(()=>b.id,{onDelete:"cascade"}),roomState:ft("roomState")},m=>[ve("idx_participants_user").on(m.entityId),ve("idx_participants_room").on(m.roomId),Se({name:"fk_room",columns:[m.roomId],foreignColumns:[c.id]}).onDelete("cascade"),Se({name:"fk_user",columns:[m.entityId],foreignColumns:[h.id]}).onDelete("cascade")]);import{sql as qe}from"drizzle-orm";import{foreignKey as Be,index as pt,jsonb as wt,pgTable as Dt,text as Ut,unique as Et,uuid as Y}from"drizzle-orm/pg-core";var _=Dt("relationships",{id:Y("id").notNull().primaryKey().default(qe`gen_random_uuid()`),createdAt:T("createdAt").default(qe`now()`).notNull(),sourceEntityId:Y("sourceEntityId").notNull().references(()=>h.id,{onDelete:"cascade"}),targetEntityId:Y("targetEntityId").notNull().references(()=>h.id,{onDelete:"cascade"}),agentId:Y("agentId").notNull().references(()=>b.id,{onDelete:"cascade"}),tags:Ut("tags").array(),metadata:wt("metadata")},m=>[pt("idx_relationships_users").on(m.sourceEntityId,m.targetEntityId),Et("unique_relationship").on(m.sourceEntityId,m.targetEntityId,m.agentId),Be({name:"fk_user_a",columns:[m.sourceEntityId],foreignColumns:[h.id]}).onDelete("cascade"),Be({name:"fk_user_b",columns:[m.targetEntityId],foreignColumns:[h.id]}).onDelete("cascade")]);import{jsonb as Tt,pgTable as At,text as se,timestamp as Re,uuid as Q}from"drizzle-orm/pg-core";var P=At("tasks",{id:Q("id").primaryKey().defaultRandom(),name:se("name").notNull(),description:se("description").notNull(),roomId:Q("room_id"),worldId:Q("world_id"),agentId:Q("agent_id").notNull(),tags:se("tags").array(),metadata:Tt("metadata"),createdAt:Re("created_at").defaultNow(),updatedAt:Re("updated_at").defaultNow()});var de=class de extends _t{constructor(e){super();this.maxRetries=3;this.baseDelay=1e3;this.maxDelay=1e4;this.jitterMax=1e3;this.embeddingDimension=L[384];this.agentId=e}async withRetry(e){let t=new Error("Unknown error");for(let r=1;r<=this.maxRetries;r++)try{return await e()}catch(i){if(t=i,r<this.maxRetries){let s=Math.min(this.baseDelay*2**(r-1),this.maxDelay),d=Math.random()*this.jitterMax,y=s+d;o.warn(`Database operation failed (attempt ${r}/${this.maxRetries}):`,{error:i instanceof Error?i.message:String(i),nextRetryIn:`${(y/1e3).toFixed(1)}s`}),await new Promise(I=>setTimeout(I,y))}else throw o.error("Max retry attempts reached:",{error:i instanceof Error?i.message:String(i),totalAttempts:r}),i instanceof Error?i:new Error(String(i))}throw t}async ensureAgentExists(e){if(!e.name)throw new Error("Agent name is required");let r=(await this.getAgents()).find(i=>i.name===e.name);return r||(e.id=Pt(e.name??O()),await this.createAgent(e),e)}async ensureEmbeddingDimension(e){let t=await this.db.select({embedding:l}).from(a).innerJoin(l,n(l.memoryId,a.id)).where(n(a.agentId,this.agentId)).limit(1);if(t.length>0){let r=Object.entries(L).find(([i,s])=>t[0].embedding[s]!==null)}this.embeddingDimension=L[e]}async getAgent(e){return this.withDatabase(async()=>{let t=await this.db.select().from(b).where(n(b.id,e)).limit(1);return t.length===0?null:t[0]})}async getAgents(){return this.withDatabase(async()=>await this.db.select().from(b))}async createAgent(e){return this.withDatabase(async()=>{try{return await this.db.transaction(async t=>{await t.insert(b).values({...e})}),o.debug("Agent created successfully:",{agentId:e.id}),!0}catch(t){return o.error("Error creating agent:",{error:t instanceof Error?t.message:String(t),agentId:e.id,agent:e}),!1}})}async updateAgent(e,t){return this.withDatabase(async()=>{try{if(!e)throw new Error("Agent ID is required for update");return await this.db.transaction(async r=>{t?.settings&&(t.settings=await this.mergeAgentSettings(r,e,t.settings)),await r.update(b).set({...t,updatedAt:Date.now()}).where(n(b.id,e))}),o.debug("Agent updated successfully:",{agentId:e}),!0}catch(r){return o.error("Error updating agent:",{error:r instanceof Error?r.message:String(r),agentId:e,agent:t}),!1}})}async mergeAgentSettings(e,t,r){let i=await e.select({settings:b.settings}).from(b).where(n(b.id,t)).limit(1);if(i.length===0||!i[0].settings)return r;let s=i[0].settings;if(r.secrets){let d=s.secrets||{},y=r.secrets,I={...d};for(let[R,A]of Object.entries(y))A===null?delete I[R]:I[R]=A;r.secrets=I}return{...s,...r}}async deleteAgent(e){return o.debug(`[DB] Starting deletion of agent with ID: ${e}`),this.withDatabase(async()=>{try{return o.debug(`[DB] Beginning database transaction for deleting agent: ${e}`),await new Promise((r,i)=>{let s=setTimeout(()=>{o.error(`[DB] Transaction timeout reached for agent deletion: ${e}`),i(new Error("Database transaction timeout"))},3e4);this.db.transaction(async d=>{try{o.debug(`[DB] Fetching entities for agent: ${e}`);let I=(await d.select({entityId:h.id}).from(h).where(n(h.agentId,e))).map(g=>g.entityId);o.debug(`[DB] Found ${I.length} entities to delete for agent ${e}`),o.debug(`[DB] Fetching rooms for agent: ${e}`);let A=(await d.select({roomId:c.id}).from(c).where(n(c.agentId,e))).map(g=>g.roomId);if(o.debug(`[DB] Found ${A.length} rooms for agent ${e}`),o.debug("[DB] Explicitly deleting ALL logs with matching entityIds and roomIds"),I.length>0){o.debug(`[DB] Deleting logs for ${I.length} entities (first batch)`);let g=50;for(let p=0;p<I.length;p+=g){let q=I.slice(p,p+g);o.debug(`[DB] Processing entity logs batch ${p/g+1} with ${q.length} entities`),await d.delete(N).where(D(N.entityId,q))}o.debug("[DB] Entity logs deletion completed successfully")}if(A.length>0){o.debug(`[DB] Deleting logs for ${A.length} rooms (first batch)`);let g=50;for(let p=0;p<A.length;p+=g){let q=A.slice(p,p+g);o.debug(`[DB] Processing room logs batch ${p/g+1} with ${q.length} rooms`),await d.delete(N).where(D(N.roomId,q))}o.debug("[DB] Room logs deletion completed successfully")}let U=[];I.length>0&&(o.debug("[DB] Finding memories belonging to entities"),U=(await d.select({id:a.id}).from(a).where(D(a.entityId,I))).map(p=>p.id),o.debug(`[DB] Found ${U.length} memories belonging to entities`)),o.debug("[DB] Finding memories belonging to agent directly");let X=await d.select({id:a.id}).from(a).where(n(a.agentId,e));if(U=[...U,...X.map(g=>g.id)],o.debug(`[DB] Found total of ${U.length} memories to delete`),A.length>0){o.debug("[DB] Finding memories belonging to rooms");let g=await d.select({id:a.id}).from(a).where(D(a.roomId,A));U=[...U,...g.map(p=>p.id)],o.debug(`[DB] Updated total to ${U.length} memories to delete`)}if(U.length>0){o.debug(`[DB] Deleting embeddings for ${U.length} memories`);let g=100;for(let p=0;p<U.length;p+=g){let q=U.slice(p,p+g);await d.delete(l).where(D(l.memoryId,q))}o.debug("[DB] Embeddings deleted successfully")}if(U.length>0){o.debug(`[DB] Deleting ${U.length} memories`);let g=100;for(let p=0;p<U.length;p+=g){let q=U.slice(p,p+g);await d.delete(a).where(D(a.id,q))}o.debug("[DB] Memories deleted successfully")}I.length>0&&(o.debug("[DB] Deleting components for entities"),await d.delete(f).where(D(f.entityId,I)),o.debug("[DB] Components deleted successfully")),I.length>0&&(o.debug("[DB] Deleting source entity references in components"),await d.delete(f).where(D(f.sourceEntityId,I)),o.debug("[DB] Source entity references deleted successfully")),A.length>0&&(o.debug("[DB] Deleting participations for rooms"),await d.delete(u).where(D(u.roomId,A)),o.debug("[DB] Participations deleted for rooms")),o.debug("[DB] Deleting agent participations"),await d.delete(u).where(n(u.agentId,e)),o.debug("[DB] Agent participations deleted"),A.length>0&&(o.debug("[DB] Deleting rooms"),await d.delete(c).where(D(c.id,A)),o.debug("[DB] Rooms deleted successfully")),o.debug("[DB] Deleting cache entries"),await d.delete(S).where(n(S.agentId,e)),o.debug("[DB] Cache entries deleted successfully"),o.debug("[DB] Deleting relationships"),I.length>0&&(await d.delete(_).where(D(_.sourceEntityId,I)),await d.delete(_).where(D(_.targetEntityId,I))),await d.delete(_).where(n(_.agentId,e)),o.debug("[DB] Relationships deleted successfully"),I.length>0&&(o.debug("[DB] Deleting entities"),await d.delete(h).where(n(h.agentId,e)),o.debug("[DB] Entities deleted successfully")),o.debug("[DB] Checking for world references");let re=await d.select({id:E.id}).from(E).where(n(E.agentId,e));if(re.length>0){let g=await d.select({newAgentId:b.id}).from(b).where(qt(n(b.id,e))).limit(1);if(g.length>0)await d.update(E).set({agentId:g[0].newAgentId}).where(n(E.agentId,e));else{let p=re.map(q=>q.id);o.debug(`[DB] Found ${p.length} worlds to delete`),await d.delete(E).where(D(E.id,p)),o.debug("[DB] Worlds deleted successfully")}}else o.debug("[DB] No worlds found for this agent");o.debug(`[DB] Deleting agent ${e}`),await d.delete(b).where(n(b.id,e)),o.debug("[DB] Agent deleted successfully"),r(!0)}catch(y){o.error("[DB] Error in transaction:",y),i(y)}}).catch(d=>{clearTimeout(s),i(d)})}),o.success(`[DB] Agent ${e} successfully deleted`),!0}catch(t){throw o.error(`[DB] Error in database transaction for agent deletion ${e}:`,t),t instanceof Error&&(o.error(`[DB] Error name: ${t.name}, message: ${t.message}`),o.error(`[DB] Error stack: ${t.stack}`)),t}})}async countAgents(){return this.withDatabase(async()=>{try{return(await this.db.select({count:Mt()}).from(b))[0]?.count||0}catch(e){return o.error("Error counting agents:",{error:e instanceof Error?e.message:String(e)}),0}})}async cleanupAgents(){return this.withDatabase(async()=>{try{await this.db.delete(b),o.success("Successfully cleaned up agent table")}catch(e){throw o.error("Error cleaning up agent table:",{error:e instanceof Error?e.message:String(e)}),e}})}async getEntityById(e){return this.withDatabase(async()=>{let t=await this.db.select({entity:h,components:f}).from(h).leftJoin(f,n(f.entityId,h.id)).where(n(h.id,e));if(t.length===0)return null;let r=t[0].entity;return r.components=t.filter(i=>i.components).map(i=>i.components),r})}async getEntitiesForRoom(e,t){return this.withDatabase(async()=>{let r=this.db.select({entity:h,...t&&{components:f}}).from(u).leftJoin(h,w(n(u.entityId,h.id),n(h.agentId,this.agentId)));t&&r.leftJoin(f,n(f.entityId,h.id));let i=await r.where(n(u.roomId,e)),s=new Map;for(let d of i){if(!d.entity)continue;let y=d.entity.id;if(!s.has(y)){let I={...d.entity,components:t?[]:void 0};s.set(y,I)}if(t&&d.components){let I=s.get(y);I&&(I.components||(I.components=[]),I.components.push(d.components))}}return Array.from(s.values())})}async createEntity(e){return this.withDatabase(async()=>{try{return await this.db.transaction(async t=>(await t.insert(h).values(e),o.debug("Entity created successfully:",{entity:e}),!0))}catch(t){return o.error("Error creating entity:",{error:t instanceof Error?t.message:String(t),entityId:e.id,name:e.metadata?.name}),o.trace(t),!1}})}async ensureEntityExists(e){if(!e.id)return o.error("Entity ID is required for ensureEntityExists"),!1;try{return await this.getEntityById(e.id)?!0:await this.createEntity(e)}catch(t){return o.error("Error ensuring entity exists:",{error:t instanceof Error?t.message:String(t),entityId:e.id}),!1}}async updateEntity(e){return this.withDatabase(async()=>{await this.db.update(h).set(e).where(w(n(h.id,e.id),n(h.agentId,e.agentId)))})}async getComponent(e,t,r,i){return this.withDatabase(async()=>{let s=[n(f.entityId,e),n(f.type,t)];r&&s.push(n(f.worldId,r)),i&&s.push(n(f.sourceEntityId,i));let d=await this.db.select().from(f).where(w(...s));return d.length>0?d[0]:null})}async getComponents(e,t,r){return this.withDatabase(async()=>{let i=[n(f.entityId,e)];return t&&i.push(n(f.worldId,t)),r&&i.push(n(f.sourceEntityId,r)),await this.db.select({id:f.id,entityId:f.entityId,type:f.type,data:f.data,worldId:f.worldId,sourceEntityId:f.sourceEntityId,createdAt:f.createdAt}).from(f).where(w(...i))})}async createComponent(e){return this.withDatabase(async()=>(await this.db.insert(f).values(e),!0))}async updateComponent(e){return this.withDatabase(async()=>{await this.db.update(f).set(e).where(n(f.id,e.id))})}async deleteComponent(e){return this.withDatabase(async()=>{await this.db.delete(f).where(n(f.id,e))})}async getMemories(e){let{entityId:t,agentId:r,roomId:i,worldId:s,tableName:d,count:y,unique:I,start:R,end:A}=e;if(!d)throw new Error("tableName is required");return this.withDatabase(async()=>{let U=[n(a.type,d)];R&&U.push(xe(a.createdAt,R)),t&&U.push(n(a.entityId,t)),i&&U.push(n(a.roomId,i)),s&&U.push(n(a.worldId,s)),A&&U.push(St(a.createdAt,A)),I&&U.push(n(a.unique,!0)),r&&U.push(n(a.agentId,r));let X=this.db.select({memory:{id:a.id,type:a.type,createdAt:a.createdAt,content:a.content,entityId:a.entityId,agentId:a.agentId,roomId:a.roomId,unique:a.unique,metadata:a.metadata},embedding:l[this.embeddingDimension]}).from(a).leftJoin(l,n(l.memoryId,a.id)).where(w(...U)).orderBy(z(a.createdAt));return(e.count?await X.limit(e.count):await X).map(g=>({id:g.memory.id,type:g.memory.type,createdAt:g.memory.createdAt,content:typeof g.memory.content=="string"?JSON.parse(g.memory.content):g.memory.content,entityId:g.memory.entityId,agentId:g.memory.agentId,roomId:g.memory.roomId,unique:g.memory.unique,metadata:g.memory.metadata,embedding:g.embedding?Array.from(g.embedding):void 0}))})}async getMemoriesByRoomIds(e){return this.withDatabase(async()=>{if(e.roomIds.length===0)return[];let t=[n(a.type,e.tableName),D(a.roomId,e.roomIds)];t.push(n(a.agentId,this.agentId));let r=this.db.select({id:a.id,type:a.type,createdAt:a.createdAt,content:a.content,entityId:a.entityId,agentId:a.agentId,roomId:a.roomId,unique:a.unique,metadata:a.metadata}).from(a).where(w(...t)).orderBy(z(a.createdAt));return(e.limit?await r.limit(e.limit):await r).map(s=>({id:s.id,createdAt:s.createdAt,content:typeof s.content=="string"?JSON.parse(s.content):s.content,entityId:s.entityId,agentId:s.agentId,roomId:s.roomId,unique:s.unique,metadata:s.metadata}))})}async getMemoryById(e){return this.withDatabase(async()=>{let t=await this.db.select({memory:a,embedding:l[this.embeddingDimension]}).from(a).leftJoin(l,n(a.id,l.memoryId)).where(n(a.id,e)).limit(1);if(t.length===0)return null;let r=t[0];return{id:r.memory.id,createdAt:r.memory.createdAt,content:typeof r.memory.content=="string"?JSON.parse(r.memory.content):r.memory.content,entityId:r.memory.entityId,agentId:r.memory.agentId,roomId:r.memory.roomId,unique:r.memory.unique,embedding:r.embedding??void 0}})}async getMemoriesByIds(e,t){return this.withDatabase(async()=>{if(e.length===0)return[];let r=[D(a.id,e)];return t&&r.push(n(a.type,t)),(await this.db.select({memory:a,embedding:l[this.embeddingDimension]}).from(a).leftJoin(l,n(l.memoryId,a.id)).where(w(...r)).orderBy(z(a.createdAt))).map(s=>({id:s.memory.id,createdAt:s.memory.createdAt,content:typeof s.memory.content=="string"?JSON.parse(s.memory.content):s.memory.content,entityId:s.memory.entityId,agentId:s.memory.agentId,roomId:s.memory.roomId,unique:s.memory.unique,metadata:s.memory.metadata,embedding:s.embedding??void 0}))})}async getCachedEmbeddings(e){return this.withDatabase(async()=>{try{return(await this.db.execute(M`
+        `
+    )
+  ]
+);
+var memoryRelations = relations(memoryTable, ({ one }) => ({
+  embedding: one(embeddingTable)
+}));
+
+// src/schema/embedding.ts
+var 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"
+};
+var embeddingTable = pgTable6(
+  "embeddings",
+  {
+    id: uuid6("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid6("memory_id").references(() => memoryTable.id),
+    createdAt: numberTimestamp("created_at").default(sql6`now()`).notNull(),
+    dim384: vector2("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
+    dim512: vector2("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
+    dim768: vector2("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
+    dim1024: vector2("dim_1024", { dimensions: VECTOR_DIMS.XL }),
+    dim1536: vector2("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
+    dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
+  },
+  (table) => [
+    check2("embedding_source_check", sql6`"memory_id" IS NOT NULL`),
+    index2("idx_embedding_memory").on(table.memoryId),
+    foreignKey2({
+      name: "fk_embedding_memory",
+      columns: [table.memoryId],
+      foreignColumns: [memoryTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/cache.ts
+import { sql as sql7 } from "drizzle-orm";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, unique as unique4, uuid as uuid7 } from "drizzle-orm/pg-core";
+var cacheTable = pgTable7(
+  "cache",
+  {
+    id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
+    key: text6("key").notNull(),
+    agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb6("value").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull(),
+    expiresAt: numberTimestamp("expiresAt")
+  },
+  (table) => [unique4("cache_key_agent_unique").on(table.key, table.agentId)]
+);
+
+// src/schema/component.ts
+import { sql as sql8 } from "drizzle-orm";
+import { jsonb as jsonb7, pgTable as pgTable8, text as text7, uuid as uuid8 } from "drizzle-orm/pg-core";
+var componentTable = pgTable8("components", {
+  id: uuid8("id").primaryKey().defaultRandom(),
+  entityId: uuid8("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid8("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  roomId: uuid8("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" }),
+  worldId: uuid8("worldId").references(() => worldTable.id, {
+    onDelete: "cascade"
+  }),
+  sourceEntityId: uuid8("sourceEntityId").references(() => entityTable.id, {
+    onDelete: "cascade"
+  }),
+  type: text7("type").notNull(),
+  data: jsonb7("data").default(sql8`'{}'::jsonb`),
+  createdAt: numberTimestamp("createdAt").default(sql8`now()`).notNull()
+});
+
+// src/schema/log.ts
+import { sql as sql9 } from "drizzle-orm";
+import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, uuid as uuid9 } from "drizzle-orm/pg-core";
+var logTable = pgTable9(
+  "logs",
+  {
+    id: uuid9("id").defaultRandom().notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql9`now()`).notNull(),
+    entityId: uuid9("entityId").notNull().references(() => entityTable.id),
+    body: jsonb8("body").notNull(),
+    type: text8("type").notNull(),
+    roomId: uuid9("roomId").notNull().references(() => roomTable.id)
+  },
+  (table) => [
+    foreignKey3({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey3({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/participant.ts
+import { sql as sql10 } from "drizzle-orm";
+import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
+var participantTable = pgTable10(
+  "participants",
+  {
+    id: uuid10("id").notNull().primaryKey().default(sql10`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql10`now()`).notNull(),
+    entityId: uuid10("entityId").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    roomId: uuid10("roomId").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid10("agentId").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    roomState: text9("roomState")
+  },
+  (table) => [
+    // unique("participants_user_room_agent_unique").on(table.entityId, table.roomId, table.agentId),
+    index3("idx_participants_user").on(table.entityId),
+    index3("idx_participants_room").on(table.roomId),
+    foreignKey4({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey4({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/relationship.ts
+import { sql as sql11 } from "drizzle-orm";
+import { foreignKey as foreignKey5, index as index4, jsonb as jsonb9, pgTable as pgTable11, text as text10, unique as unique6, uuid as uuid11 } from "drizzle-orm/pg-core";
+var relationshipTable = pgTable11(
+  "relationships",
+  {
+    id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql11`now()`).notNull(),
+    sourceEntityId: uuid11("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    targetEntityId: uuid11("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid11("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text10("tags").array(),
+    metadata: jsonb9("metadata")
+  },
+  (table) => [
+    index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+    unique6("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+    foreignKey5({
+      name: "fk_user_a",
+      columns: [table.sourceEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    foreignKey5({
+      name: "fk_user_b",
+      columns: [table.targetEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/tasks.ts
+import { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp, uuid as uuid12 } from "drizzle-orm/pg-core";
+var taskTable = pgTable12("tasks", {
+  id: uuid12("id").primaryKey().defaultRandom(),
+  name: text11("name").notNull(),
+  description: text11("description").notNull(),
+  roomId: uuid12("room_id"),
+  worldId: uuid12("world_id"),
+  agentId: uuid12("agent_id").notNull(),
+  tags: text11("tags").array(),
+  metadata: jsonb10("metadata"),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow()
+});
+
+// src/base.ts
+var BaseDrizzleAdapter = class extends DatabaseAdapter {
+  static {
+    __name(this, "BaseDrizzleAdapter");
+  }
+  maxRetries = 3;
+  baseDelay = 1e3;
+  maxDelay = 1e4;
+  jitterMax = 1e3;
+  embeddingDimension = DIMENSION_MAP[384];
+  agentId;
+  /**
+   * Constructor for creating a new instance of Agent with the specified agentId.
+   *
+   * @param {UUID} agentId - The unique identifier for the agent.
+   */
+  constructor(agentId) {
+    super();
+    this.agentId = agentId;
+  }
+  /**
+   * Executes the given operation with retry logic.
+   * @template T
+   * @param {() => Promise<T>} operation - The operation to be executed.
+   * @returns {Promise<T>} A promise that resolves with the result of the operation.
+   */
+  async withRetry(operation) {
+    let lastError = new Error("Unknown error");
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          const backoffDelay = Math.min(this.baseDelay * 2 ** (attempt - 1), this.maxDelay);
+          const jitter = Math.random() * this.jitterMax;
+          const delay = backoffDelay + jitter;
+          logger.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}):`, {
+            error: error instanceof Error ? error.message : String(error),
+            nextRetryIn: `${(delay / 1e3).toFixed(1)}s`
+          });
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          logger.error("Max retry attempts reached:", {
+            error: error instanceof Error ? error.message : String(error),
+            totalAttempts: attempt
+          });
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Asynchronously ensures that an agent exists by checking if an agent with the same name already exists in the system.
+   * If the agent does not exist, it will be created with the provided data.
+   *
+   * @param {Partial<Agent>} agent - The partial data of the agent to ensure its existence.
+   * @returns {Promise<void>} - A promise that resolves when the agent is successfully ensured.
+   * @throws {Error} - If the agent name is not provided or if there is an issue creating the agent.
+   */
+  async ensureAgentExists(agent) {
+    if (!agent.name) {
+      throw new Error("Agent name is required");
+    }
+    const agents = await this.getAgents();
+    const existingAgent = agents.find(
+      (a) => a.name === agent.name
+    );
+    if (existingAgent) {
+      return existingAgent;
+    }
+    agent.id = stringToUuid(agent.name ?? v4());
+    await this.createAgent(agent);
+    return agent;
+  }
+  /**
+   * Asynchronously ensures that the given embedding dimension is valid for the agent.
+   *
+   * @param {number} dimension - The dimension to ensure for the embedding.
+   * @returns {Promise<void>} - Resolves once the embedding dimension is ensured.
+   */
+  async ensureEmbeddingDimension(dimension) {
+    const existingMemory = await this.db.select({
+      embedding: embeddingTable
+    }).from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
+    if (existingMemory.length > 0) {
+      const usedDimension = Object.entries(DIMENSION_MAP).find(
+        ([_, colName]) => existingMemory[0].embedding[colName] !== null
+      );
+    }
+    this.embeddingDimension = DIMENSION_MAP[dimension];
+  }
+  /**
+   * Asynchronously retrieves an agent by their ID from the database.
+   * @param {UUID} agentId - The ID of the agent to retrieve.
+   * @returns {Promise<Agent | null>} A promise that resolves to the retrieved agent or null if not found.
+   */
+  async getAgent(agentId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+      if (result.length === 0) return null;
+      return result[0];
+    });
+  }
+  /**
+   * Asynchronously retrieves a list of agents from the database.
+   *
+   * @returns {Promise<Agent[]>} A Promise that resolves to an array of Agent objects.
+   */
+  async getAgents() {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(agentTable);
+      return result;
+    });
+  }
+  /**
+   * Asynchronously creates a new agent record in the database.
+   *
+   * @param {Partial<Agent>} agent The agent object to be created.
+   * @returns {Promise<boolean>} A promise that resolves to a boolean indicating the success of the operation.
+   */
+  async createAgent(agent) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(agentTable).values({
+            ...agent
+          });
+        });
+        logger.debug("Agent created successfully:", {
+          agentId: agent.id
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error creating agent:", {
+          error: error instanceof Error ? error.message : String(error),
+          agentId: agent.id,
+          agent
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Updates an agent in the database with the provided agent ID and data.
+   * @param {UUID} agentId - The unique identifier of the agent to update.
+   * @param {Partial<Agent>} agent - The partial agent object containing the fields to update.
+   * @returns {Promise<boolean>} - A boolean indicating if the agent was successfully updated.
+   */
+  async updateAgent(agentId, agent) {
+    return this.withDatabase(async () => {
+      try {
+        if (!agentId) {
+          throw new Error("Agent ID is required for update");
+        }
+        await this.db.transaction(async (tx) => {
+          if (agent?.settings) {
+            agent.settings = await this.mergeAgentSettings(tx, agentId, agent.settings);
+          }
+          await tx.update(agentTable).set({
+            ...agent,
+            updatedAt: Date.now()
+          }).where(eq(agentTable.id, agentId));
+        });
+        logger.debug("Agent updated successfully:", {
+          agentId
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error updating agent:", {
+          error: error instanceof Error ? error.message : String(error),
+          agentId,
+          agent
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Merges updated agent settings with existing settings in the database,
+   * with special handling for nested objects like secrets.
+   * @param tx - The database transaction
+   * @param agentId - The ID of the agent
+   * @param updatedSettings - The settings object with updates
+   * @returns The merged settings object
+   * @private
+   */
+  async mergeAgentSettings(tx, agentId, updatedSettings) {
+    const currentAgent = await tx.select({ settings: agentTable.settings }).from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+    if (currentAgent.length === 0 || !currentAgent[0].settings) {
+      return updatedSettings;
+    }
+    const currentSettings = currentAgent[0].settings;
+    if (updatedSettings.secrets) {
+      const currentSecrets = currentSettings.secrets || {};
+      const updatedSecrets = updatedSettings.secrets;
+      const mergedSecrets = { ...currentSecrets };
+      for (const [key, value] of Object.entries(updatedSecrets)) {
+        if (value === null) {
+          delete mergedSecrets[key];
+        } else {
+          mergedSecrets[key] = value;
+        }
+      }
+      updatedSettings.secrets = mergedSecrets;
+    }
+    return {
+      ...currentSettings,
+      ...updatedSettings
+    };
+  }
+  /**
+   * Asynchronously deletes an agent with the specified UUID and all related entries.
+   *
+   * @param {UUID} agentId - The UUID of the agent to be deleted.
+   * @returns {Promise<boolean>} - A boolean indicating if the deletion was successful.
+   */
+  async deleteAgent(agentId) {
+    logger.debug(`[DB] Starting deletion of agent with ID: ${agentId}`);
+    return this.withDatabase(async () => {
+      try {
+        logger.debug(`[DB] Beginning database transaction for deleting agent: ${agentId}`);
+        const deletePromise = new Promise((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            logger.error(`[DB] Transaction timeout reached for agent deletion: ${agentId}`);
+            reject(new Error("Database transaction timeout"));
+          }, 3e4);
+          this.db.transaction(async (tx) => {
+            try {
+              logger.debug(`[DB] Fetching entities for agent: ${agentId}`);
+              const entities = await tx.select({ entityId: entityTable.id }).from(entityTable).where(eq(entityTable.agentId, agentId));
+              const entityIds = entities.map((e) => e.entityId);
+              logger.debug(
+                `[DB] Found ${entityIds.length} entities to delete for agent ${agentId}`
+              );
+              logger.debug(`[DB] Fetching rooms for agent: ${agentId}`);
+              const rooms = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.agentId, agentId));
+              const roomIds = rooms.map((r) => r.roomId);
+              logger.debug(`[DB] Found ${roomIds.length} rooms for agent ${agentId}`);
+              logger.debug(
+                `[DB] Explicitly deleting ALL logs with matching entityIds and roomIds`
+              );
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting logs for ${entityIds.length} entities (first batch)`);
+                const BATCH_SIZE = 50;
+                for (let i = 0; i < entityIds.length; i += BATCH_SIZE) {
+                  const batch = entityIds.slice(i, i + BATCH_SIZE);
+                  logger.debug(
+                    `[DB] Processing entity logs batch ${i / BATCH_SIZE + 1} with ${batch.length} entities`
+                  );
+                  await tx.delete(logTable).where(inArray(logTable.entityId, batch));
+                }
+                logger.debug(`[DB] Entity logs deletion completed successfully`);
+              }
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting logs for ${roomIds.length} rooms (first batch)`);
+                const BATCH_SIZE = 50;
+                for (let i = 0; i < roomIds.length; i += BATCH_SIZE) {
+                  const batch = roomIds.slice(i, i + BATCH_SIZE);
+                  logger.debug(
+                    `[DB] Processing room logs batch ${i / BATCH_SIZE + 1} with ${batch.length} rooms`
+                  );
+                  await tx.delete(logTable).where(inArray(logTable.roomId, batch));
+                }
+                logger.debug(`[DB] Room logs deletion completed successfully`);
+              }
+              let memoryIds = [];
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Finding memories belonging to entities`);
+                const memories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.entityId, entityIds));
+                memoryIds = memories.map((m) => m.id);
+                logger.debug(`[DB] Found ${memoryIds.length} memories belonging to entities`);
+              }
+              logger.debug(`[DB] Finding memories belonging to agent directly`);
+              const agentMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(eq(memoryTable.agentId, agentId));
+              memoryIds = [...memoryIds, ...agentMemories.map((m) => m.id)];
+              logger.debug(`[DB] Found total of ${memoryIds.length} memories to delete`);
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Finding memories belonging to rooms`);
+                const roomMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+                memoryIds = [...memoryIds, ...roomMemories.map((m) => m.id)];
+                logger.debug(`[DB] Updated total to ${memoryIds.length} memories to delete`);
+              }
+              if (memoryIds.length > 0) {
+                logger.debug(`[DB] Deleting embeddings for ${memoryIds.length} memories`);
+                const BATCH_SIZE = 100;
+                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
+                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
+                  await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, batch));
+                }
+                logger.debug(`[DB] Embeddings deleted successfully`);
+              }
+              if (memoryIds.length > 0) {
+                logger.debug(`[DB] Deleting ${memoryIds.length} memories`);
+                const BATCH_SIZE = 100;
+                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
+                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
+                  await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
+                }
+                logger.debug(`[DB] Memories deleted successfully`);
+              }
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting components for entities`);
+                await tx.delete(componentTable).where(inArray(componentTable.entityId, entityIds));
+                logger.debug(`[DB] Components deleted successfully`);
+              }
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting source entity references in components`);
+                await tx.delete(componentTable).where(inArray(componentTable.sourceEntityId, entityIds));
+                logger.debug(`[DB] Source entity references deleted successfully`);
+              }
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting participations for rooms`);
+                await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+                logger.debug(`[DB] Participations deleted for rooms`);
+              }
+              logger.debug(`[DB] Deleting agent participations`);
+              await tx.delete(participantTable).where(eq(participantTable.agentId, agentId));
+              logger.debug(`[DB] Agent participations deleted`);
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting rooms`);
+                await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
+                logger.debug(`[DB] Rooms deleted successfully`);
+              }
+              logger.debug(`[DB] Deleting cache entries`);
+              await tx.delete(cacheTable).where(eq(cacheTable.agentId, agentId));
+              logger.debug(`[DB] Cache entries deleted successfully`);
+              logger.debug(`[DB] Deleting relationships`);
+              if (entityIds.length > 0) {
+                await tx.delete(relationshipTable).where(inArray(relationshipTable.sourceEntityId, entityIds));
+                await tx.delete(relationshipTable).where(inArray(relationshipTable.targetEntityId, entityIds));
+              }
+              await tx.delete(relationshipTable).where(eq(relationshipTable.agentId, agentId));
+              logger.debug(`[DB] Relationships deleted successfully`);
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting entities`);
+                await tx.delete(entityTable).where(eq(entityTable.agentId, agentId));
+                logger.debug(`[DB] Entities deleted successfully`);
+              }
+              logger.debug(`[DB] Checking for world references`);
+              const worlds = await tx.select({ id: worldTable.id }).from(worldTable).where(eq(worldTable.agentId, agentId));
+              if (worlds.length > 0) {
+                const newAgent = await tx.select({ newAgentId: agentTable.id }).from(agentTable).where(not(eq(agentTable.id, agentId))).limit(1);
+                if (newAgent.length > 0) {
+                  await tx.update(worldTable).set({ agentId: newAgent[0].newAgentId }).where(eq(worldTable.agentId, agentId));
+                } else {
+                  const worldIds = worlds.map((w) => w.id);
+                  logger.debug(`[DB] Found ${worldIds.length} worlds to delete`);
+                  await tx.delete(worldTable).where(inArray(worldTable.id, worldIds));
+                  logger.debug(`[DB] Worlds deleted successfully`);
+                }
+              } else {
+                logger.debug(`[DB] No worlds found for this agent`);
+              }
+              logger.debug(`[DB] Deleting agent ${agentId}`);
+              await tx.delete(agentTable).where(eq(agentTable.id, agentId));
+              logger.debug(`[DB] Agent deleted successfully`);
+              resolve(true);
+            } catch (error) {
+              logger.error(`[DB] Error in transaction:`, error);
+              reject(error);
+            }
+          }).catch((transactionError) => {
+            clearTimeout(timeoutId);
+            reject(transactionError);
+          });
+        });
+        await deletePromise;
+        logger.success(`[DB] Agent ${agentId} successfully deleted`);
+        return true;
+      } catch (error) {
+        logger.error(`[DB] Error in database transaction for agent deletion ${agentId}:`, error);
+        if (error instanceof Error) {
+          logger.error(`[DB] Error name: ${error.name}, message: ${error.message}`);
+          logger.error(`[DB] Error stack: ${error.stack}`);
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Count all agents in the database
+   * Used primarily for maintenance and cleanup operations
+   */
+  /**
+   * Asynchronously counts the number of agents in the database.
+   * @returns {Promise<number>} A Promise that resolves to the number of agents in the database.
+   */
+  async countAgents() {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.select({ count: count() }).from(agentTable);
+        return result[0]?.count || 0;
+      } catch (error) {
+        logger.error("Error counting agents:", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return 0;
+      }
+    });
+  }
+  /**
+   * Clean up the agents table by removing all agents
+   * This is used during server startup to ensure no orphaned agents exist
+   * from previous crashes or improper shutdowns
+   */
+  async cleanupAgents() {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.delete(agentTable);
+        logger.success("Successfully cleaned up agent table");
+      } catch (error) {
+        logger.error("Error cleaning up agent table:", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves an entity and its components by entity ID.
+   * @param {UUID} entityId - The unique identifier of the entity to retrieve.
+   * @returns {Promise<Entity | null>} A Promise that resolves to the entity with its components if found, null otherwise.
+   */
+  async getEntityById(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        entity: entityTable,
+        components: componentTable
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(eq(entityTable.id, entityId));
+      if (result.length === 0) return null;
+      const entity = result[0].entity;
+      entity.components = result.filter((row) => row.components).map((row) => row.components);
+      return entity;
+    });
+  }
+  /**
+   * Asynchronously retrieves all entities for a given room, optionally including their components.
+   * @param {UUID} roomId - The unique identifier of the room to get entities for
+   * @param {boolean} [includeComponents] - Whether to include component data for each entity
+   * @returns {Promise<Entity[]>} A Promise that resolves to an array of entities in the room
+   */
+  async getEntitiesForRoom(roomId, includeComponents) {
+    return this.withDatabase(async () => {
+      const query = this.db.select({
+        entity: entityTable,
+        ...includeComponents && { components: componentTable }
+      }).from(participantTable).leftJoin(
+        entityTable,
+        and(eq(participantTable.entityId, entityTable.id), eq(entityTable.agentId, this.agentId))
+      );
+      if (includeComponents) {
+        query.leftJoin(componentTable, eq(componentTable.entityId, entityTable.id));
+      }
+      const result = await query.where(eq(participantTable.roomId, roomId));
+      const entitiesByIdMap = /* @__PURE__ */ new Map();
+      for (const row of result) {
+        if (!row.entity) continue;
+        const entityId = row.entity.id;
+        if (!entitiesByIdMap.has(entityId)) {
+          const entity = {
+            ...row.entity,
+            components: includeComponents ? [] : void 0
+          };
+          entitiesByIdMap.set(entityId, entity);
+        }
+        if (includeComponents && row.components) {
+          const entity = entitiesByIdMap.get(entityId);
+          if (entity) {
+            if (!entity.components) {
+              entity.components = [];
+            }
+            entity.components.push(row.components);
+          }
+        }
+      }
+      return Array.from(entitiesByIdMap.values());
+    });
+  }
+  /**
+   * Asynchronously creates a new entity in the database.
+   * @param {Entity} entity - The entity object to be created.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
+   */
+  async createEntity(entity) {
+    return this.withDatabase(async () => {
+      try {
+        return await this.db.transaction(async (tx) => {
+          await tx.insert(entityTable).values(entity);
+          logger.debug("Entity created successfully:", {
+            entity
+          });
+          return true;
+        });
+      } catch (error) {
+        logger.error("Error creating entity:", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId: entity.id,
+          name: entity.metadata?.name
+        });
+        logger.trace(error);
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously ensures an entity exists, creating it if it doesn't
+   * @param entity The entity to ensure exists
+   * @returns Promise resolving to boolean indicating success
+   */
+  async ensureEntityExists(entity) {
+    if (!entity.id) {
+      logger.error("Entity ID is required for ensureEntityExists");
+      return false;
+    }
+    try {
+      const existingEntity = await this.getEntityById(entity.id);
+      if (!existingEntity) {
+        return await this.createEntity(entity);
+      }
+      return true;
+    } catch (error) {
+      logger.error("Error ensuring entity exists:", {
+        error: error instanceof Error ? error.message : String(error),
+        entityId: entity.id
+      });
+      return false;
+    }
+  }
+  /**
+   * Asynchronously updates an entity in the database.
+   * @param {Entity} entity - The entity object to be updated.
+   * @returns {Promise<void>} A Promise that resolves when the entity is updated.
+   */
+  async updateEntity(entity) {
+    return this.withDatabase(async () => {
+      await this.db.update(entityTable).set(entity).where(and(eq(entityTable.id, entity.id), eq(entityTable.agentId, entity.agentId)));
+    });
+  }
+  async getComponent(entityId, type, worldId, sourceEntityId) {
+    return this.withDatabase(async () => {
+      const conditions = [eq(componentTable.entityId, entityId), eq(componentTable.type, type)];
+      if (worldId) {
+        conditions.push(eq(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select().from(componentTable).where(and(...conditions));
+      return result.length > 0 ? result[0] : null;
+    });
+  }
+  /**
+   * Asynchronously retrieves all components for a given entity, optionally filtered by world and source entity.
+   * @param {UUID} entityId - The unique identifier of the entity to retrieve components for
+   * @param {UUID} [worldId] - Optional world ID to filter components by
+   * @param {UUID} [sourceEntityId] - Optional source entity ID to filter components by
+   * @returns {Promise<Component[]>} A Promise that resolves to an array of components
+   */
+  async getComponents(entityId, worldId, sourceEntityId) {
+    return this.withDatabase(async () => {
+      const conditions = [eq(componentTable.entityId, entityId)];
+      if (worldId) {
+        conditions.push(eq(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select({
+        id: componentTable.id,
+        entityId: componentTable.entityId,
+        type: componentTable.type,
+        data: componentTable.data,
+        worldId: componentTable.worldId,
+        sourceEntityId: componentTable.sourceEntityId,
+        createdAt: componentTable.createdAt
+      }).from(componentTable).where(and(...conditions));
+      return result;
+    });
+  }
+  /**
+   * Asynchronously creates a new component in the database.
+   * @param {Component} component - The component object to be created.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
+   */
+  async createComponent(component) {
+    return this.withDatabase(async () => {
+      await this.db.insert(componentTable).values(component);
+      return true;
+    });
+  }
+  /**
+   * Asynchronously updates an existing component in the database.
+   * @param {Component} component - The component object to be updated.
+   * @returns {Promise<void>} A Promise that resolves when the component is updated.
+   */
+  async updateComponent(component) {
+    return this.withDatabase(async () => {
+      await this.db.update(componentTable).set(component).where(eq(componentTable.id, component.id));
+    });
+  }
+  /**
+   * Asynchronously deletes a component from the database.
+   * @param {UUID} componentId - The unique identifier of the component to delete.
+   * @returns {Promise<void>} A Promise that resolves when the component is deleted.
+   */
+  async deleteComponent(componentId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(componentTable).where(eq(componentTable.id, componentId));
+    });
+  }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID} params.roomId - The ID of the room to retrieve memories for.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.tableName] - The name of the table to retrieve memories from.
+   * @param {number} [params.start] - The start date to retrieve memories from.
+   * @param {number} [params.end] - The end date to retrieve memories from.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
+  async getMemories(params) {
+    const { entityId, agentId, roomId, worldId, tableName, count: count2, unique: unique7, start, end } = params;
+    if (!tableName) throw new Error("tableName is required");
+    return this.withDatabase(async () => {
+      const conditions = [eq(memoryTable.type, tableName)];
+      if (start) {
+        conditions.push(gte(memoryTable.createdAt, start));
+      }
+      if (entityId) {
+        conditions.push(eq(memoryTable.entityId, entityId));
+      }
+      if (roomId) {
+        conditions.push(eq(memoryTable.roomId, roomId));
+      }
+      if (worldId) {
+        conditions.push(eq(memoryTable.worldId, worldId));
+      }
+      if (end) {
+        conditions.push(lte(memoryTable.createdAt, end));
+      }
+      if (unique7) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      if (agentId) {
+        conditions.push(eq(memoryTable.agentId, agentId));
+      }
+      const query = this.db.select({
+        memory: {
+          id: memoryTable.id,
+          type: memoryTable.type,
+          createdAt: memoryTable.createdAt,
+          content: memoryTable.content,
+          entityId: memoryTable.entityId,
+          agentId: memoryTable.agentId,
+          roomId: memoryTable.roomId,
+          unique: memoryTable.unique,
+          metadata: memoryTable.metadata
+        },
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.count ? await query.limit(params.count) : await query;
+      return rows.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        metadata: row.memory.metadata,
+        embedding: row.embedding ? Array.from(row.embedding) : void 0
+      }));
+    });
+  }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID[]} params.roomIds - The IDs of the rooms to retrieve memories for.
+   * @param {string} params.tableName - The name of the table to retrieve memories from.
+   * @param {number} [params.limit] - The maximum number of memories to retrieve.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
+  async getMemoriesByRoomIds(params) {
+    return this.withDatabase(async () => {
+      if (params.roomIds.length === 0) return [];
+      const conditions = [
+        eq(memoryTable.type, params.tableName),
+        inArray(memoryTable.roomId, params.roomIds)
+      ];
+      conditions.push(eq(memoryTable.agentId, this.agentId));
+      const query = this.db.select({
+        id: memoryTable.id,
+        type: memoryTable.type,
+        createdAt: memoryTable.createdAt,
+        content: memoryTable.content,
+        entityId: memoryTable.entityId,
+        agentId: memoryTable.agentId,
+        roomId: memoryTable.roomId,
+        unique: memoryTable.unique,
+        metadata: memoryTable.metadata
+      }).from(memoryTable).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.limit ? await query.limit(params.limit) : await query;
+      return rows.map((row) => ({
+        id: row.id,
+        createdAt: row.createdAt,
+        content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
+        entityId: row.entityId,
+        agentId: row.agentId,
+        roomId: row.roomId,
+        unique: row.unique,
+        metadata: row.metadata
+      }));
+    });
+  }
+  /**
+   * Asynchronously retrieves a memory by its unique identifier.
+   * @param {UUID} id - The unique identifier of the memory to retrieve.
+   * @returns {Promise<Memory | null>} A Promise that resolves to the memory if found, null otherwise.
+   */
+  async getMemoryById(id) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(memoryTable.id, embeddingTable.memoryId)).where(eq(memoryTable.id, id)).limit(1);
+      if (result.length === 0) return null;
+      const row = result[0];
+      return {
+        id: row.memory.id,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0
+      };
+    });
+  }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID[]} params.memoryIds - The IDs of the memories to retrieve.
+   * @param {string} [params.tableName] - The name of the table to retrieve memories from.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
+  async getMemoriesByIds(memoryIds, tableName) {
+    return this.withDatabase(async () => {
+      if (memoryIds.length === 0) return [];
+      const conditions = [inArray(memoryTable.id, memoryIds)];
+      if (tableName) {
+        conditions.push(eq(memoryTable.type, tableName));
+      }
+      const rows = await this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      return rows.map((row) => ({
+        id: row.memory.id,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        metadata: row.memory.metadata,
+        embedding: row.embedding ?? void 0
+      }));
+    });
+  }
+  /**
+   * Asynchronously retrieves cached embeddings from the database based on the provided parameters.
+   * @param {Object} opts - The parameters for retrieving cached embeddings.
+   * @param {string} opts.query_table_name - The name of the table to retrieve embeddings from.
+   * @param {number} opts.query_threshold - The threshold for the levenshtein distance.
+   * @param {string} opts.query_input - The input string to search for.
+   * @param {string} opts.query_field_name - The name of the field to retrieve embeddings from.
+   * @param {string} opts.query_field_sub_name - The name of the sub-field to retrieve embeddings from.
+   * @param {number} opts.query_match_count - The maximum number of matches to retrieve.
+   * @returns {Promise<{ embedding: number[]; levenshtein_score: number }[]>} A Promise that resolves to an array of cached embeddings.
+   */
+  async getCachedEmbeddings(opts) {
+    return this.withDatabase(async () => {
+      try {
+        const results = await this.db.execute(sql12`
                     WITH content_text AS (
                         SELECT
                             m.id,
                             COALESCE(
-                                m.content->>${e.query_field_sub_name},
+                                m.content->>${opts.query_field_sub_name},
                                 ''
                             ) as content_text
                         FROM memories m
-                        WHERE m.type = ${e.query_table_name}
-                            AND m.content->>${e.query_field_sub_name} IS NOT NULL
+                        WHERE m.type = ${opts.query_table_name}
+                            AND m.content->>${opts.query_field_sub_name} IS NOT NULL
                     ),
                     embedded_text AS (
                         SELECT 
@@ -40,10 +1236,1287 @@ import{a as x,b as ge,c as ye}from"./chunk-K7ZVMPCJ.js";import*as ke from"node:o
                     )
                     SELECT
                         embedding,
-                        levenshtein(${e.query_input}, content_text) as levenshtein_score
+                        levenshtein(${opts.query_input}, content_text) as levenshtein_score
                     FROM embedded_text
-                    WHERE levenshtein(${e.query_input}, content_text) <= ${e.query_threshold}
+                    WHERE levenshtein(${opts.query_input}, content_text) <= ${opts.query_threshold}
                     ORDER BY levenshtein_score
-                    LIMIT ${e.query_match_count}
-                `)).rows.map(r=>({embedding:Array.isArray(r.embedding)?r.embedding:typeof r.embedding=="string"?JSON.parse(r.embedding):[],levenshtein_score:Number(r.levenshtein_score)})).filter(r=>Array.isArray(r.embedding))}catch(t){if(o.error("Error in getCachedEmbeddings:",{error:t instanceof Error?t.message:String(t),tableName:e.query_table_name,fieldName:e.query_field_name}),t instanceof Error&&t.message==="levenshtein argument exceeds maximum length of 255 characters")return[];throw t}})}async log(e){return this.withDatabase(async()=>{try{await this.db.transaction(async t=>{await t.insert(N).values({body:M`${e.body}::jsonb`,entityId:e.entityId,roomId:e.roomId,type:e.type})})}catch(t){throw o.error("Failed to create log entry:",{error:t instanceof Error?t.message:String(t),type:e.type,roomId:e.roomId,entityId:e.entityId}),t}})}async getLogs(e){let{entityId:t,roomId:r,type:i,count:s,offset:d}=e;return this.withDatabase(async()=>await this.db.select().from(N).where(w(n(N.entityId,t),r?n(N.roomId,r):void 0,i?n(N.type,i):void 0)).orderBy(z(N.createdAt)).limit(s??10).offset(d??0))}async deleteLog(e){return this.withDatabase(async()=>{await this.db.delete(N).where(n(N.id,e))})}async searchMemories(e){return await this.searchMemoriesByEmbedding(e.embedding,{match_threshold:e.match_threshold,count:e.count,roomId:e.roomId,worldId:e.worldId,entityId:e.entityId,unique:e.unique,tableName:e.tableName})}async searchMemoriesByEmbedding(e,t){return this.withDatabase(async()=>{let r=e.map(y=>Number.isFinite(y)?Number(y.toFixed(6)):0),i=M`1 - (${Nt(l[this.embeddingDimension],r)})`,s=[n(a.type,t.tableName)];return t.unique&&s.push(n(a.unique,!0)),s.push(n(a.agentId,this.agentId)),t.roomId&&s.push(n(a.roomId,t.roomId)),t.worldId&&s.push(n(a.worldId,t.worldId)),t.entityId&&s.push(n(a.entityId,t.entityId)),t.match_threshold&&s.push(xe(i,t.match_threshold)),(await this.db.select({memory:a,similarity:i,embedding:l[this.embeddingDimension]}).from(l).innerJoin(a,n(a.id,l.memoryId)).where(w(...s)).orderBy(z(i)).limit(t.count??10)).map(y=>({id:y.memory.id,type:y.memory.type,createdAt:y.memory.createdAt,content:typeof y.memory.content=="string"?JSON.parse(y.memory.content):y.memory.content,entityId:y.memory.entityId,agentId:y.memory.agentId,roomId:y.memory.roomId,worldId:y.memory.worldId,unique:y.memory.unique,metadata:y.memory.metadata,embedding:y.embedding??void 0,similarity:y.similarity}))})}async createMemory(e,t){o.debug("DrizzleAdapter createMemory:",{memoryId:e.id,embeddingLength:e.embedding?.length,contentLength:e.content?.text?.length});let r=e.id??O();if(await this.getMemoryById(r))return o.debug("Memory already exists, skipping creation:",{memoryId:r}),r;let s=!0;e.embedding&&Array.isArray(e.embedding)&&(s=(await this.searchMemoriesByEmbedding(e.embedding,{tableName:t,roomId:e.roomId,worldId:e.worldId,entityId:e.entityId,match_threshold:.95,count:1})).length===0);let d=typeof e.content=="string"?JSON.parse(e.content):e.content;return await this.db.transaction(async y=>{if(await y.insert(a).values([{id:r,type:t,content:M`${d}::jsonb`,metadata:M`${e.metadata||{}}::jsonb`,entityId:e.entityId,roomId:e.roomId,worldId:e.worldId,agentId:e.agentId,unique:e.unique??s,createdAt:e.createdAt}]),e.embedding&&Array.isArray(e.embedding)){let I={id:O(),memoryId:r,createdAt:e.createdAt},R=e.embedding.map(A=>Number.isFinite(A)?Number(A.toFixed(6)):0);I[this.embeddingDimension]=R,await y.insert(l).values([I])}}),r}async updateMemory(e){return this.withDatabase(async()=>{try{return o.debug("Updating memory:",{memoryId:e.id,hasEmbedding:!!e.embedding}),await this.db.transaction(async t=>{if(e.content){let r=typeof e.content=="string"?JSON.parse(e.content):e.content;await t.update(a).set({content:M`${r}::jsonb`,...e.metadata&&{metadata:M`${e.metadata}::jsonb`}}).where(n(a.id,e.id))}else e.metadata&&await t.update(a).set({metadata:M`${e.metadata}::jsonb`}).where(n(a.id,e.id));if(e.embedding&&Array.isArray(e.embedding)){let r=e.embedding.map(s=>Number.isFinite(s)?Number(s.toFixed(6)):0);if((await t.select({id:l.id}).from(l).where(n(l.memoryId,e.id)).limit(1)).length>0){let s={};s[this.embeddingDimension]=r,await t.update(l).set(s).where(n(l.memoryId,e.id))}else{let s={id:O(),memoryId:e.id,createdAt:Date.now()};s[this.embeddingDimension]=r,await t.insert(l).values([s])}}}),o.debug("Memory updated successfully:",{memoryId:e.id}),!0}catch(t){return o.error("Error updating memory:",{error:t instanceof Error?t.message:String(t),memoryId:e.id}),!1}})}async deleteMemory(e){return this.withDatabase(async()=>{await this.db.transaction(async t=>{await this.deleteMemoryFragments(t,e),await t.delete(l).where(n(l.memoryId,e)),await t.delete(a).where(n(a.id,e))}),o.debug("Memory and related fragments removed successfully:",{memoryId:e})})}async deleteMemoryFragments(e,t){let r=await this.getMemoryFragments(e,t);if(r.length>0){let i=r.map(s=>s.id);await e.delete(l).where(D(l.memoryId,i)),await e.delete(a).where(D(a.id,i)),o.debug("Deleted related fragments:",{documentId:t,fragmentCount:r.length})}}async getMemoryFragments(e,t){return await e.select({id:a.id}).from(a).where(w(n(a.agentId,this.agentId),M`${a.metadata}->>'documentId' = ${t}`))}async deleteAllMemories(e,t){return this.withDatabase(async()=>{await this.db.transaction(async r=>{let i=await r.select({id:a.id}).from(a).where(w(n(a.roomId,e),n(a.type,t)));i.length>0&&(await r.delete(l).where(D(l.memoryId,i.map(s=>s.id))),await r.delete(a).where(w(n(a.roomId,e),n(a.type,t))))}),o.debug("All memories removed successfully:",{roomId:e,tableName:t})})}async countMemories(e,t=!0,r=""){if(!r)throw new Error("tableName is required");return this.withDatabase(async()=>{let i=[n(a.roomId,e),n(a.type,r)];t&&i.push(n(a.unique,!0));let s=await this.db.select({count:M`count(*)`}).from(a).where(w(...i));return Number(s[0]?.count??0)})}async getRoom(e){return this.withDatabase(async()=>{let t=await this.db.select({id:c.id,channelId:c.channelId,agentId:c.agentId,serverId:c.serverId,worldId:c.worldId,type:c.type,source:c.source}).from(c).where(w(n(c.id,e),n(c.agentId,this.agentId))).limit(1);return t.length===0?null:t[0]})}async getRooms(e){return this.withDatabase(async()=>await this.db.select().from(c).where(n(c.worldId,e)))}async updateRoom(e){return this.withDatabase(async()=>{await this.db.update(c).set({...e,agentId:this.agentId}).where(n(c.id,e.id))})}async createRoom({id:e,name:t,agentId:r,source:i,type:s,channelId:d,serverId:y,worldId:I,metadata:R}){return this.withDatabase(async()=>{let A=e||O();return await this.db.insert(c).values({id:A,name:t,agentId:r,source:i,type:s,channelId:d,serverId:y,worldId:I,metadata:R}).onConflictDoNothing({target:c.id}),A})}async deleteRoom(e){if(!e)throw new Error("Room ID is required");return this.withDatabase(async()=>{await this.db.transaction(async t=>{await t.delete(c).where(n(c.id,e))})})}async getRoomsForParticipant(e){return this.withDatabase(async()=>(await this.db.select({roomId:u.roomId}).from(u).innerJoin(c,n(u.roomId,c.id)).where(w(n(u.entityId,e),n(c.agentId,this.agentId)))).map(r=>r.roomId))}async getRoomsForParticipants(e){return this.withDatabase(async()=>(await this.db.selectDistinct({roomId:u.roomId}).from(u).innerJoin(c,n(u.roomId,c.id)).where(w(D(u.entityId,e),n(c.agentId,this.agentId)))).map(r=>r.roomId))}async addParticipant(e,t){return this.withDatabase(async()=>{try{return await this.db.insert(u).values({entityId:e,roomId:t,agentId:this.agentId}).onConflictDoNothing(),!0}catch(r){return o.error("Error adding participant",{error:r instanceof Error?r.message:String(r),entityId:e,roomId:t,agentId:this.agentId}),!1}})}async removeParticipant(e,t){return this.withDatabase(async()=>{try{let i=(await this.db.transaction(async s=>await s.delete(u).where(w(n(u.entityId,e),n(u.roomId,t))).returning())).length>0;return o.debug(`Participant ${i?"removed":"not found"}:`,{entityId:e,roomId:t,removed:i}),i}catch(r){return o.error("Failed to remove participant:",{error:r instanceof Error?r.message:String(r),entityId:e,roomId:t}),!1}})}async getParticipantsForEntity(e){return this.withDatabase(async()=>{let t=await this.db.select({id:u.id,entityId:u.entityId,roomId:u.roomId}).from(u).where(n(u.entityId,e)),r=await this.getEntityById(e);return r?t.map(i=>({id:i.id,entity:r})):[]})}async getParticipantsForRoom(e){return this.withDatabase(async()=>(await this.db.select({entityId:u.entityId}).from(u).where(n(u.roomId,e))).map(r=>r.entityId))}async getParticipantUserState(e,t){return this.withDatabase(async()=>(await this.db.select({roomState:u.roomState}).from(u).where(w(n(u.roomId,e),n(u.entityId,t),n(u.agentId,this.agentId))).limit(1))[0]?.roomState??null)}async setParticipantUserState(e,t,r){return this.withDatabase(async()=>{try{await this.db.transaction(async i=>{await i.update(u).set({roomState:r}).where(w(n(u.roomId,e),n(u.entityId,t),n(u.agentId,this.agentId)))})}catch(i){throw o.error("Failed to set participant user state:",{roomId:e,entityId:t,state:r,error:i instanceof Error?i.message:String(i)}),i}})}async createRelationship(e){return this.withDatabase(async()=>{let r={id:O(),sourceEntityId:e.sourceEntityId,targetEntityId:e.targetEntityId,agentId:this.agentId,tags:e.tags||[],metadata:e.metadata||{}};try{return await this.db.insert(_).values(r),!0}catch(i){return o.error("Error creating relationship:",{error:i instanceof Error?i.message:String(i),saveParams:r}),!1}})}async updateRelationship(e){return this.withDatabase(async()=>{try{await this.db.update(_).set({tags:e.tags||[],metadata:e.metadata||{}}).where(n(_.id,e.id))}catch(t){throw o.error("Error updating relationship:",{error:t instanceof Error?t.message:String(t),relationship:e}),t}})}async getRelationship(e){return this.withDatabase(async()=>{try{let t=await this.db.select().from(_).where(w(n(_.sourceEntityId,e.sourceEntityId),n(_.targetEntityId,e.targetEntityId),n(_.agentId,this.agentId))).limit(1);return t.length===0?null:{id:t[0].id,sourceEntityId:t[0].sourceEntityId,targetEntityId:t[0].targetEntityId,agentId:t[0].agentId,tags:t[0].tags||[],metadata:t[0].metadata||{},createdAt:t[0].createdAt?.toString()}}catch(t){return o.error("Error getting relationship:",{error:t instanceof Error?t.message:String(t),params:e}),null}})}async getRelationships(e){return this.withDatabase(async()=>{try{let t=this.db.select().from(_).where(w(vt(n(_.sourceEntityId,e.entityId),n(_.targetEntityId,e.entityId)),n(_.agentId,this.agentId)));if(e.tags&&e.tags.length>0){let i=e.tags.map(s=>`'${s.replace(/'/g,"''")}'`).join(", ");t=t.where(M`${_.tags} @> ARRAY[${M.raw(i)}]::text[]`)}return(await t).map(i=>({id:i.id,sourceEntityId:i.sourceEntityId,targetEntityId:i.targetEntityId,agentId:i.agentId,tags:i.tags||[],metadata:i.metadata||{},createdAt:i.createdAt?.toString()}))}catch(t){return o.error("Error getting relationships:",{error:t instanceof Error?t.message:String(t),params:e}),[]}})}async getCache(e){return this.withDatabase(async()=>{try{return(await this.db.select().from(S).where(w(n(S.agentId,this.agentId),n(S.key,e))))[0]?.value}catch(t){o.error("Error fetching cache",{error:t instanceof Error?t.message:String(t),key:e,agentId:this.agentId});return}})}async setCache(e,t){return this.withDatabase(async()=>{try{return await this.db.transaction(async r=>{await r.insert(S).values({key:e,agentId:this.agentId,value:t}).onConflictDoUpdate({target:[S.key,S.agentId],set:{value:t}})}),!0}catch(r){return o.error("Error setting cache",{error:r instanceof Error?r.message:String(r),key:e,agentId:this.agentId}),!1}})}async deleteCache(e){return this.withDatabase(async()=>{try{return await this.db.transaction(async t=>{await t.delete(S).where(w(n(S.agentId,this.agentId),n(S.key,e)))}),!0}catch(t){return o.error("Error deleting cache",{error:t instanceof Error?t.message:String(t),key:e,agentId:this.agentId}),!1}})}async createWorld(e){return this.withDatabase(async()=>{let t=e.id||O();return await this.db.insert(E).values({...e,id:t}),t})}async getWorld(e){return this.withDatabase(async()=>(await this.db.select().from(E).where(n(E.id,e)))[0])}async getAllWorlds(){return this.withDatabase(async()=>await this.db.select().from(E).where(n(E.agentId,this.agentId)))}async updateWorld(e){return this.withDatabase(async()=>{await this.db.update(E).set(e).where(n(E.id,e.id))})}async removeWorld(e){return this.withDatabase(async()=>{await this.db.delete(E).where(n(E.id,e))})}async createTask(e){return this.withRetry(async()=>this.withDatabase(async()=>{let t=new Date,r=e.metadata||{},i={id:e.id,name:e.name,description:e.description,roomId:e.roomId,worldId:e.worldId,tags:e.tags,metadata:r,createdAt:t,updatedAt:t,agentId:this.agentId};return(await this.db.insert(P).values(i).returning({id:P.id}))[0].id}))}async getTasks(e){return this.withRetry(async()=>this.withDatabase(async()=>{let t=this.db.select().from(P).where(n(P.agentId,this.agentId));if(e.roomId&&(t=t.where(n(P.roomId,e.roomId))),e.tags&&e.tags.length>0){let i=e.tags.map(s=>`'${s.replace(/'/g,"''")}'`).join(", ");t=t.where(M`${P.tags} @> ARRAY[${M.raw(i)}]::text[]`)}return(await t).map(i=>({id:i.id,name:i.name,description:i.description,roomId:i.roomId,worldId:i.worldId,tags:i.tags,metadata:i.metadata}))}))}async getTasksByName(e){return this.withRetry(async()=>this.withDatabase(async()=>(await this.db.select().from(P).where(w(n(P.name,e),n(P.agentId,this.agentId)))).map(r=>({id:r.id,name:r.name,description:r.description,roomId:r.roomId,worldId:r.worldId,tags:r.tags||[],metadata:r.metadata||{}}))))}async getTask(e){return this.withRetry(async()=>this.withDatabase(async()=>{let t=await this.db.select().from(P).where(w(n(P.id,e),n(P.agentId,this.agentId))).limit(1);if(t.length===0)return null;let r=t[0];return{id:r.id,name:r.name,description:r.description,roomId:r.roomId,worldId:r.worldId,tags:r.tags||[],metadata:r.metadata||{}}}))}async updateTask(e,t){await this.withRetry(async()=>{await this.withDatabase(async()=>{let r={};if(t.name!==void 0&&(r.name=t.name),t.description!==void 0&&(r.description=t.description),t.roomId!==void 0&&(r.roomId=t.roomId),t.worldId!==void 0&&(r.worldId=t.worldId),t.tags!==void 0&&(r.tags=t.tags),t.updatedAt=Date.now(),t.metadata){let i=await this.getTask(e);if(i){let d={...i.metadata||{},...t.metadata};r.metadata=d}else r.metadata={...t.metadata}}await this.db.update(P).set(r).where(w(n(P.id,e),n(P.agentId,this.agentId)))})})}async deleteTask(e){await this.withRetry(async()=>{await this.withDatabase(async()=>{await this.db.delete(P).where(w(n(P.id,e),n(P.agentId,this.agentId)))})})}async getMemoriesByServerId(e){return this.withDatabase(async()=>{let t=await this.db.select({roomId:c.id}).from(c).where(n(c.serverId,e.serverId));if(t.length===0)return[];let r=t.map(d=>d.roomId),i=this.db.select({memory:a,embedding:l[this.embeddingDimension]}).from(a).leftJoin(l,n(l.memoryId,a.id)).where(D(a.roomId,r)).orderBy(z(a.createdAt));return(e.count?await i.limit(e.count):await i).map(d=>({id:d.memory.id,type:d.memory.type,createdAt:d.memory.createdAt,content:typeof d.memory.content=="string"?JSON.parse(d.memory.content):d.memory.content,entityId:d.memory.entityId,agentId:d.memory.agentId,roomId:d.memory.roomId,unique:d.memory.unique,embedding:d.embedding??void 0}))})}async deleteRoomsByServerId(e){return this.withDatabase(async()=>{await this.db.transaction(async t=>{let r=await t.select({roomId:c.id}).from(c).where(n(c.serverId,e));if(r.length===0)return;let i=r.map(s=>s.roomId);await t.delete(l).where(D(l.memoryId,t.select({id:a.id}).from(a).where(D(a.roomId,i)))),await t.delete(a).where(D(a.roomId,i)),await t.delete(u).where(D(u.roomId,i)),await t.delete(N).where(D(N.roomId,i)),await t.delete(c).where(D(c.id,i))}),o.debug("Rooms and related logs deleted successfully for server:",{serverId:e})})}};x(de,"BaseDrizzleAdapter");var J=de;var me=class me extends J{constructor(e,t){super(e);this.embeddingDimension=L[384];this.manager=t,this.db=Bt(this.manager.getConnection())}async withDatabase(e){return this.manager.isShuttingDown()?(Ce.warn("Database is shutting down"),null):e()}async init(){try{await this.manager.runMigrations()}catch(e){throw Ce.error("Failed to initialize database:",e),e}}async close(){await this.manager.close()}};x(me,"PgliteDatabaseAdapter");var ee=me;import{logger as $e}from"@elizaos/core";import{drizzle as Rt}from"drizzle-orm/node-postgres";var ce=class ce extends J{constructor(e,t){super(e);this.manager=t;this.embeddingDimension=L[384];this.manager=t}async withDatabase(e){return await this.withRetry(async()=>{let t=await this.manager.getClient();try{let r=Rt(t);return this.db=r,await e()}finally{t.release()}})}async init(){try{await this.manager.runMigrations(),$e.debug("PgDatabaseAdapter initialized successfully")}catch(e){throw $e.error("Failed to initialize PgDatabaseAdapter:",e),e}}async close(){await this.manager.close()}};x(ce,"PgDatabaseAdapter");var te=ce;var le=Symbol.for("@elizaos/plugin-sql/global-singletons"),ue=global;ue[le]||(ue[le]={});var W=ue[le];function xt(m){return m&&typeof m=="string"&&m.startsWith("~")?m.replace(/^~/,ke.homedir()):m}x(xt,"expandTildePath");function Ct(m,B){if(m.dataDir&&(m.dataDir=xt(m.dataDir)),m.postgresUrl)return W.postgresConnectionManager||(W.postgresConnectionManager=new ye(m.postgresUrl)),new te(B,W.postgresConnectionManager);let e=m.dataDir??"./elizadb";return W.pgLiteClientManager||(W.pgLiteClientManager=new ge({dataDir:e})),new ee(B,W.pgLiteClientManager)}x(Ct,"createDatabaseAdapter");var $t={name:"sql",description:"SQL database adapter plugin using Drizzle ORM",init:x(async(m,B)=>{let e={dataDir:B.getSetting("PGLITE_DATA_DIR")??"./pglite",postgresUrl:B.getSetting("POSTGRES_URL")};try{let t=Ct(e,B.agentId);Le.success("Database connection established successfully"),B.registerDatabaseAdapter(t)}catch(t){throw Le.error("Failed to initialize database:",t),t}},"init")},Wn=$t;export{Ct as createDatabaseAdapter,Wn as default};
+                    LIMIT ${opts.query_match_count}
+                `);
+        return results.rows.map((row) => ({
+          embedding: Array.isArray(row.embedding) ? row.embedding : typeof row.embedding === "string" ? JSON.parse(row.embedding) : [],
+          levenshtein_score: Number(row.levenshtein_score)
+        })).filter((row) => Array.isArray(row.embedding));
+      } catch (error) {
+        logger.error("Error in getCachedEmbeddings:", {
+          error: error instanceof Error ? error.message : String(error),
+          tableName: opts.query_table_name,
+          fieldName: opts.query_field_name
+        });
+        if (error instanceof Error && error.message === "levenshtein argument exceeds maximum length of 255 characters") {
+          return [];
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Asynchronously logs an event in the database.
+   * @param {Object} params - The parameters for logging an event.
+   * @param {Object} params.body - The body of the event to log.
+   * @param {UUID} params.entityId - The ID of the entity associated with the event.
+   * @param {UUID} params.roomId - The ID of the room associated with the event.
+   * @param {string} params.type - The type of the event to log.
+   * @returns {Promise<void>} A Promise that resolves when the event is logged.
+   */
+  async log(params) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(logTable).values({
+            body: sql12`${params.body}::jsonb`,
+            entityId: params.entityId,
+            roomId: params.roomId,
+            type: params.type
+          });
+        });
+      } catch (error) {
+        logger.error("Failed to create log entry:", {
+          error: error instanceof Error ? error.message : String(error),
+          type: params.type,
+          roomId: params.roomId,
+          entityId: params.entityId
+        });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves logs from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving logs.
+   * @param {UUID} params.entityId - The ID of the entity associated with the logs.
+   * @param {UUID} [params.roomId] - The ID of the room associated with the logs.
+   * @param {string} [params.type] - The type of the logs to retrieve.
+   * @param {number} [params.count] - The maximum number of logs to retrieve.
+   * @param {number} [params.offset] - The offset to retrieve logs from.
+   * @returns {Promise<Log[]>} A Promise that resolves to an array of logs.
+   */
+  async getLogs(params) {
+    const { entityId, roomId, type, count: count2, offset } = params;
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(logTable).where(
+        and(
+          eq(logTable.entityId, entityId),
+          roomId ? eq(logTable.roomId, roomId) : void 0,
+          type ? eq(logTable.type, type) : void 0
+        )
+      ).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
+      return result;
+    });
+  }
+  /**
+   * Asynchronously deletes a log from the database based on the provided parameters.
+   * @param {UUID} logId - The ID of the log to delete.
+   * @returns {Promise<void>} A Promise that resolves when the log is deleted.
+   */
+  async deleteLog(logId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(logTable).where(eq(logTable.id, logId));
+    });
+  }
+  /**
+   * Asynchronously searches for memories in the database based on the provided parameters.
+   * @param {Object} params - The parameters for searching for memories.
+   * @param {string} params.tableName - The name of the table to search for memories in.
+   * @param {number[]} params.embedding - The embedding to search for.
+   * @param {number} [params.match_threshold] - The threshold for the cosine distance.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.query] - Optional query string for potential reranking.
+   * @param {UUID} [params.roomId] - Optional room ID to filter by.
+   * @param {UUID} [params.worldId] - Optional world ID to filter by.
+   * @param {UUID} [params.entityId] - Optional entity ID to filter by.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
+  async searchMemories(params) {
+    return await this.searchMemoriesByEmbedding(params.embedding, {
+      match_threshold: params.match_threshold,
+      count: params.count,
+      // Pass direct scope fields down
+      roomId: params.roomId,
+      worldId: params.worldId,
+      entityId: params.entityId,
+      unique: params.unique,
+      tableName: params.tableName
+    });
+  }
+  /**
+   * Asynchronously searches for memories in the database based on the provided parameters.
+   * @param {number[]} embedding - The embedding to search for.
+   * @param {Object} params - The parameters for searching for memories.
+   * @param {number} [params.match_threshold] - The threshold for the cosine distance.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {UUID} [params.roomId] - Optional room ID to filter by.
+   * @param {UUID} [params.worldId] - Optional world ID to filter by.
+   * @param {UUID} [params.entityId] - Optional entity ID to filter by.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.tableName] - The name of the table to search for memories in.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
+  async searchMemoriesByEmbedding(embedding, params) {
+    return this.withDatabase(async () => {
+      const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
+      const similarity = sql12`1 - (${cosineDistance(
+        embeddingTable[this.embeddingDimension],
+        cleanVector
+      )})`;
+      const conditions = [eq(memoryTable.type, params.tableName)];
+      if (params.unique) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      conditions.push(eq(memoryTable.agentId, this.agentId));
+      if (params.roomId) {
+        conditions.push(eq(memoryTable.roomId, params.roomId));
+      }
+      if (params.worldId) {
+        conditions.push(eq(memoryTable.worldId, params.worldId));
+      }
+      if (params.entityId) {
+        conditions.push(eq(memoryTable.entityId, params.entityId));
+      }
+      if (params.match_threshold) {
+        conditions.push(gte(similarity, params.match_threshold));
+      }
+      const results = await this.db.select({
+        memory: memoryTable,
+        similarity,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(embeddingTable).innerJoin(memoryTable, eq(memoryTable.id, embeddingTable.memoryId)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.count ?? 10);
+      return results.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        worldId: row.memory.worldId,
+        // Include worldId
+        unique: row.memory.unique,
+        metadata: row.memory.metadata,
+        embedding: row.embedding ?? void 0,
+        similarity: row.similarity
+      }));
+    });
+  }
+  /**
+   * Asynchronously creates a new memory in the database.
+   * @param {Memory & { metadata?: MemoryMetadata }} memory - The memory object to create.
+   * @param {string} tableName - The name of the table to create the memory in.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created memory.
+   */
+  async createMemory(memory, tableName) {
+    logger.debug("DrizzleAdapter createMemory:", {
+      memoryId: memory.id,
+      embeddingLength: memory.embedding?.length,
+      contentLength: memory.content?.text?.length
+    });
+    const memoryId = memory.id ?? v4();
+    const existing = await this.getMemoryById(memoryId);
+    if (existing) {
+      logger.debug("Memory already exists, skipping creation:", {
+        memoryId
+      });
+      return memoryId;
+    }
+    let isUnique = true;
+    if (memory.embedding && Array.isArray(memory.embedding)) {
+      const similarMemories = await this.searchMemoriesByEmbedding(memory.embedding, {
+        tableName,
+        // Use the scope fields from the memory object for similarity check
+        roomId: memory.roomId,
+        worldId: memory.worldId,
+        entityId: memory.entityId,
+        match_threshold: 0.95,
+        count: 1
+      });
+      isUnique = similarMemories.length === 0;
+    }
+    const contentToInsert = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
+    await this.db.transaction(async (tx) => {
+      await tx.insert(memoryTable).values([
+        {
+          id: memoryId,
+          type: tableName,
+          content: sql12`${contentToInsert}::jsonb`,
+          metadata: sql12`${memory.metadata || {}}::jsonb`,
+          entityId: memory.entityId,
+          roomId: memory.roomId,
+          worldId: memory.worldId,
+          // Include worldId
+          agentId: memory.agentId,
+          unique: memory.unique ?? isUnique,
+          createdAt: memory.createdAt
+        }
+      ]);
+      if (memory.embedding && Array.isArray(memory.embedding)) {
+        const embeddingValues = {
+          id: v4(),
+          memoryId,
+          createdAt: memory.createdAt
+        };
+        const cleanVector = memory.embedding.map(
+          (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+        );
+        embeddingValues[this.embeddingDimension] = cleanVector;
+        await tx.insert(embeddingTable).values([embeddingValues]);
+      }
+    });
+    return memoryId;
+  }
+  /**
+   * Updates an existing memory in the database.
+   * @param memory The memory object with updated content and optional embedding
+   * @returns Promise resolving to boolean indicating success
+   */
+  async updateMemory(memory) {
+    return this.withDatabase(async () => {
+      try {
+        logger.debug("Updating memory:", {
+          memoryId: memory.id,
+          hasEmbedding: !!memory.embedding
+        });
+        await this.db.transaction(async (tx) => {
+          if (memory.content) {
+            const contentToUpdate = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
+            await tx.update(memoryTable).set({
+              content: sql12`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql12`${memory.metadata}::jsonb` }
+            }).where(eq(memoryTable.id, memory.id));
+          } else if (memory.metadata) {
+            await tx.update(memoryTable).set({
+              metadata: sql12`${memory.metadata}::jsonb`
+            }).where(eq(memoryTable.id, memory.id));
+          }
+          if (memory.embedding && Array.isArray(memory.embedding)) {
+            const cleanVector = memory.embedding.map(
+              (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+            );
+            const existingEmbedding = await tx.select({ id: embeddingTable.id }).from(embeddingTable).where(eq(embeddingTable.memoryId, memory.id)).limit(1);
+            if (existingEmbedding.length > 0) {
+              const updateValues = {};
+              updateValues[this.embeddingDimension] = cleanVector;
+              await tx.update(embeddingTable).set(updateValues).where(eq(embeddingTable.memoryId, memory.id));
+            } else {
+              const embeddingValues = {
+                id: v4(),
+                memoryId: memory.id,
+                createdAt: Date.now()
+              };
+              embeddingValues[this.embeddingDimension] = cleanVector;
+              await tx.insert(embeddingTable).values([embeddingValues]);
+            }
+          }
+        });
+        logger.debug("Memory updated successfully:", {
+          memoryId: memory.id
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error updating memory:", {
+          error: error instanceof Error ? error.message : String(error),
+          memoryId: memory.id
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously deletes a memory from the database based on the provided parameters.
+   * @param {UUID} memoryId - The ID of the memory to delete.
+   * @returns {Promise<void>} A Promise that resolves when the memory is deleted.
+   */
+  async deleteMemory(memoryId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await this.deleteMemoryFragments(tx, memoryId);
+        await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
+        await tx.delete(memoryTable).where(eq(memoryTable.id, memoryId));
+      });
+      logger.debug("Memory and related fragments removed successfully:", {
+        memoryId
+      });
+    });
+  }
+  /**
+   * Deletes all memory fragments that reference a specific document memory
+   * @param tx The database transaction
+   * @param documentId The UUID of the document memory whose fragments should be deleted
+   * @private
+   */
+  async deleteMemoryFragments(tx, documentId) {
+    const fragmentsToDelete = await this.getMemoryFragments(tx, documentId);
+    if (fragmentsToDelete.length > 0) {
+      const fragmentIds = fragmentsToDelete.map((f) => f.id);
+      await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
+      await tx.delete(memoryTable).where(inArray(memoryTable.id, fragmentIds));
+      logger.debug("Deleted related fragments:", {
+        documentId,
+        fragmentCount: fragmentsToDelete.length
+      });
+    }
+  }
+  /**
+   * Retrieves all memory fragments that reference a specific document memory
+   * @param tx The database transaction
+   * @param documentId The UUID of the document memory whose fragments should be retrieved
+   * @returns An array of memory fragments
+   * @private
+   */
+  async getMemoryFragments(tx, documentId) {
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
+      and(
+        eq(memoryTable.agentId, this.agentId),
+        sql12`${memoryTable.metadata}->>'documentId' = ${documentId}`
+      )
+    );
+    return fragments;
+  }
+  /**
+   * Asynchronously deletes all memories from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to delete memories from.
+   * @param {string} tableName - The name of the table to delete memories from.
+   * @returns {Promise<void>} A Promise that resolves when the memories are deleted.
+   */
+  async deleteAllMemories(roomId, tableName) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        const memoryIds = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        if (memoryIds.length > 0) {
+          await tx.delete(embeddingTable).where(
+            inArray(
+              embeddingTable.memoryId,
+              memoryIds.map((m) => m.id)
+            )
+          );
+          await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        }
+      });
+      logger.debug("All memories removed successfully:", {
+        roomId,
+        tableName
+      });
+    });
+  }
+  /**
+   * Asynchronously counts the number of memories in the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to count memories in.
+   * @param {boolean} [unique] - Whether to count unique memories only.
+   * @param {string} [tableName] - The name of the table to count memories in.
+   * @returns {Promise<number>} A Promise that resolves to the number of memories.
+   */
+  async countMemories(roomId, unique7 = true, tableName = "") {
+    if (!tableName) throw new Error("tableName is required");
+    return this.withDatabase(async () => {
+      const conditions = [eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)];
+      if (unique7) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      const result = await this.db.select({ count: sql12`count(*)` }).from(memoryTable).where(and(...conditions));
+      return Number(result[0]?.count ?? 0);
+    });
+  }
+  /**
+   * Asynchronously retrieves a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve.
+   * @returns {Promise<Room | null>} A Promise that resolves to the room if found, null otherwise.
+   */
+  async getRoom(roomId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        id: roomTable.id,
+        channelId: roomTable.channelId,
+        agentId: roomTable.agentId,
+        serverId: roomTable.serverId,
+        worldId: roomTable.worldId,
+        type: roomTable.type,
+        source: roomTable.source
+      }).from(roomTable).where(and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))).limit(1);
+      if (result.length === 0) return null;
+      return result[0];
+    });
+  }
+  /**
+   * Asynchronously retrieves all rooms from the database based on the provided parameters.
+   * @param {UUID} worldId - The ID of the world to retrieve rooms from.
+   * @returns {Promise<Room[]>} A Promise that resolves to an array of rooms.
+   */
+  async getRooms(worldId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
+      return result;
+    });
+  }
+  /**
+   * Asynchronously updates a room in the database based on the provided parameters.
+   * @param {Room} room - The room object to update.
+   * @returns {Promise<void>} A Promise that resolves when the room is updated.
+   */
+  async updateRoom(room) {
+    return this.withDatabase(async () => {
+      await this.db.update(roomTable).set({ ...room, agentId: this.agentId }).where(eq(roomTable.id, room.id));
+    });
+  }
+  /**
+   * Asynchronously creates a new room in the database based on the provided parameters.
+   * @param {Room} room - The room object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created room.
+   */
+  async createRoom({
+    id,
+    name,
+    agentId,
+    source,
+    type,
+    channelId,
+    serverId,
+    worldId,
+    metadata
+  }) {
+    return this.withDatabase(async () => {
+      const newRoomId = id || v4();
+      await this.db.insert(roomTable).values({
+        id: newRoomId,
+        name,
+        agentId,
+        source,
+        type,
+        channelId,
+        serverId,
+        worldId,
+        metadata
+      }).onConflictDoNothing({ target: roomTable.id });
+      return newRoomId;
+    });
+  }
+  /**
+   * Asynchronously deletes a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to delete.
+   * @returns {Promise<void>} A Promise that resolves when the room is deleted.
+   */
+  async deleteRoom(roomId) {
+    if (!roomId) throw new Error("Room ID is required");
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(roomTable).where(eq(roomTable.id, roomId));
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves all rooms for a participant from the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to retrieve rooms for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of room IDs.
+   */
+  async getRoomsForParticipant(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(and(eq(participantTable.entityId, entityId), eq(roomTable.agentId, this.agentId)));
+      return result.map((row) => row.roomId);
+    });
+  }
+  /**
+   * Asynchronously retrieves all rooms for a list of participants from the database based on the provided parameters.
+   * @param {UUID[]} entityIds - The IDs of the entities to retrieve rooms for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of room IDs.
+   */
+  async getRoomsForParticipants(entityIds) {
+    return this.withDatabase(async () => {
+      const result = await this.db.selectDistinct({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(
+        and(inArray(participantTable.entityId, entityIds), eq(roomTable.agentId, this.agentId))
+      );
+      return result.map((row) => row.roomId);
+    });
+  }
+  /**
+   * Asynchronously adds a participant to a room in the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to add to the room.
+   * @param {UUID} roomId - The ID of the room to add the entity to.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the participant was added successfully.
+   */
+  async addParticipant(entityId, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.insert(participantTable).values({
+          entityId,
+          roomId,
+          agentId: this.agentId
+        }).onConflictDoNothing();
+        return true;
+      } catch (error) {
+        logger.error("Error adding participant", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId,
+          roomId,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously removes a participant from a room in the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to remove from the room.
+   * @param {UUID} roomId - The ID of the room to remove the entity from.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the participant was removed successfully.
+   */
+  async removeParticipant(entityId, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.transaction(async (tx) => {
+          return await tx.delete(participantTable).where(
+            and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))
+          ).returning();
+        });
+        const removed = result.length > 0;
+        logger.debug(`Participant ${removed ? "removed" : "not found"}:`, {
+          entityId,
+          roomId,
+          removed
+        });
+        return removed;
+      } catch (error) {
+        logger.error("Failed to remove participant:", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId,
+          roomId
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves all participants for an entity from the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to retrieve participants for.
+   * @returns {Promise<Participant[]>} A Promise that resolves to an array of participants.
+   */
+  async getParticipantsForEntity(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        id: participantTable.id,
+        entityId: participantTable.entityId,
+        roomId: participantTable.roomId
+      }).from(participantTable).where(eq(participantTable.entityId, entityId));
+      const entity = await this.getEntityById(entityId);
+      if (!entity) {
+        return [];
+      }
+      return result.map((row) => ({
+        id: row.id,
+        entity
+      }));
+    });
+  }
+  /**
+   * Asynchronously retrieves all participants for a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve participants for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of entity IDs.
+   */
+  async getParticipantsForRoom(roomId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(eq(participantTable.roomId, roomId));
+      return result.map((row) => row.entityId);
+    });
+  }
+  /**
+   * Asynchronously retrieves the user state for a participant in a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve the participant's user state for.
+   * @param {UUID} entityId - The ID of the entity to retrieve the user state for.
+   * @returns {Promise<"FOLLOWED" | "MUTED" | null>} A Promise that resolves to the participant's user state.
+   */
+  async getParticipantUserState(roomId, entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(
+        and(
+          eq(participantTable.roomId, roomId),
+          eq(participantTable.entityId, entityId),
+          eq(participantTable.agentId, this.agentId)
+        )
+      ).limit(1);
+      return result[0]?.roomState ?? null;
+    });
+  }
+  /**
+   * Asynchronously sets the user state for a participant in a room in the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to set the participant's user state for.
+   * @param {UUID} entityId - The ID of the entity to set the user state for.
+   * @param {string} state - The state to set the participant's user state to.
+   * @returns {Promise<void>} A Promise that resolves when the participant's user state is set.
+   */
+  async setParticipantUserState(roomId, entityId, state) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.update(participantTable).set({ roomState: state }).where(
+            and(
+              eq(participantTable.roomId, roomId),
+              eq(participantTable.entityId, entityId),
+              eq(participantTable.agentId, this.agentId)
+            )
+          );
+        });
+      } catch (error) {
+        logger.error("Failed to set participant user state:", {
+          roomId,
+          entityId,
+          state,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Asynchronously creates a new relationship in the database based on the provided parameters.
+   * @param {Object} params - The parameters for creating a new relationship.
+   * @param {UUID} params.sourceEntityId - The ID of the source entity.
+   * @param {UUID} params.targetEntityId - The ID of the target entity.
+   * @param {string[]} [params.tags] - The tags for the relationship.
+   * @param {Object} [params.metadata] - The metadata for the relationship.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the relationship was created successfully.
+   */
+  async createRelationship(params) {
+    return this.withDatabase(async () => {
+      const id = v4();
+      const saveParams = {
+        id,
+        sourceEntityId: params.sourceEntityId,
+        targetEntityId: params.targetEntityId,
+        agentId: this.agentId,
+        tags: params.tags || [],
+        metadata: params.metadata || {}
+      };
+      try {
+        await this.db.insert(relationshipTable).values(saveParams);
+        return true;
+      } catch (error) {
+        logger.error("Error creating relationship:", {
+          error: error instanceof Error ? error.message : String(error),
+          saveParams
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously updates an existing relationship in the database based on the provided parameters.
+   * @param {Relationship} relationship - The relationship object to update.
+   * @returns {Promise<void>} A Promise that resolves when the relationship is updated.
+   */
+  async updateRelationship(relationship) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.update(relationshipTable).set({
+          tags: relationship.tags || [],
+          metadata: relationship.metadata || {}
+        }).where(eq(relationshipTable.id, relationship.id));
+      } catch (error) {
+        logger.error("Error updating relationship:", {
+          error: error instanceof Error ? error.message : String(error),
+          relationship
+        });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves a relationship from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving a relationship.
+   * @param {UUID} params.sourceEntityId - The ID of the source entity.
+   * @param {UUID} params.targetEntityId - The ID of the target entity.
+   * @returns {Promise<Relationship | null>} A Promise that resolves to the relationship if found, null otherwise.
+   */
+  async getRelationship(params) {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.select().from(relationshipTable).where(
+          and(
+            eq(relationshipTable.sourceEntityId, params.sourceEntityId),
+            eq(relationshipTable.targetEntityId, params.targetEntityId),
+            eq(relationshipTable.agentId, this.agentId)
+          )
+        ).limit(1);
+        if (result.length === 0) {
+          return null;
+        }
+        return {
+          id: result[0].id,
+          sourceEntityId: result[0].sourceEntityId,
+          targetEntityId: result[0].targetEntityId,
+          agentId: result[0].agentId,
+          tags: result[0].tags || [],
+          metadata: result[0].metadata || {},
+          createdAt: result[0].createdAt?.toString()
+        };
+      } catch (error) {
+        logger.error("Error getting relationship:", {
+          error: error instanceof Error ? error.message : String(error),
+          params
+        });
+        return null;
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves all relationships from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving relationships.
+   * @param {UUID} params.entityId - The ID of the entity to retrieve relationships for.
+   * @param {string[]} [params.tags] - The tags to filter relationships by.
+   * @returns {Promise<Relationship[]>} A Promise that resolves to an array of relationships.
+   */
+  async getRelationships(params) {
+    return this.withDatabase(async () => {
+      try {
+        let query = this.db.select().from(relationshipTable).where(
+          and(
+            or(
+              eq(relationshipTable.sourceEntityId, params.entityId),
+              eq(relationshipTable.targetEntityId, params.entityId)
+            ),
+            eq(relationshipTable.agentId, this.agentId)
+          )
+        );
+        if (params.tags && params.tags.length > 0) {
+          const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
+          query = query.where(
+            sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
+          );
+        }
+        const results = await query;
+        return results.map((result) => ({
+          id: result.id,
+          sourceEntityId: result.sourceEntityId,
+          targetEntityId: result.targetEntityId,
+          agentId: result.agentId,
+          tags: result.tags || [],
+          metadata: result.metadata || {},
+          createdAt: result.createdAt?.toString()
+        }));
+      } catch (error) {
+        logger.error("Error getting relationships:", {
+          error: error instanceof Error ? error.message : String(error),
+          params
+        });
+        return [];
+      }
+    });
+  }
+  /**
+   * Asynchronously retrieves a cache value from the database based on the provided key.
+   * @param {string} key - The key to retrieve the cache value for.
+   * @returns {Promise<T | undefined>} A Promise that resolves to the cache value if found, undefined otherwise.
+   */
+  async getCache(key) {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.select().from(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
+        return result[0]?.value;
+      } catch (error) {
+        logger.error("Error fetching cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return void 0;
+      }
+    });
+  }
+  /**
+   * Asynchronously sets a cache value in the database based on the provided key and value.
+   * @param {string} key - The key to set the cache value for.
+   * @param {T} value - The value to set in the cache.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the cache value was set successfully.
+   */
+  async setCache(key, value) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(cacheTable).values({
+            key,
+            agentId: this.agentId,
+            value
+          }).onConflictDoUpdate({
+            target: [cacheTable.key, cacheTable.agentId],
+            set: {
+              value
+            }
+          });
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error setting cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously deletes a cache value from the database based on the provided key.
+   * @param {string} key - The key to delete the cache value for.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the cache value was deleted successfully.
+   */
+  async deleteCache(key) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.delete(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error deleting cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously creates a new world in the database based on the provided parameters.
+   * @param {World} world - The world object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created world.
+   */
+  async createWorld(world) {
+    return this.withDatabase(async () => {
+      const newWorldId = world.id || v4();
+      await this.db.insert(worldTable).values({
+        ...world,
+        id: newWorldId
+      });
+      return newWorldId;
+    });
+  }
+  /**
+   * Asynchronously retrieves a world from the database based on the provided parameters.
+   * @param {UUID} id - The ID of the world to retrieve.
+   * @returns {Promise<World | null>} A Promise that resolves to the world if found, null otherwise.
+   */
+  async getWorld(id) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(eq(worldTable.id, id));
+      return result[0];
+    });
+  }
+  /**
+   * Asynchronously retrieves all worlds from the database based on the provided parameters.
+   * @returns {Promise<World[]>} A Promise that resolves to an array of worlds.
+   */
+  async getAllWorlds() {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(eq(worldTable.agentId, this.agentId));
+      return result;
+    });
+  }
+  /**
+   * Asynchronously updates an existing world in the database based on the provided parameters.
+   * @param {World} world - The world object to update.
+   * @returns {Promise<void>} A Promise that resolves when the world is updated.
+   */
+  async updateWorld(world) {
+    return this.withDatabase(async () => {
+      await this.db.update(worldTable).set(world).where(eq(worldTable.id, world.id));
+    });
+  }
+  /**
+   * Asynchronously removes a world from the database based on the provided parameters.
+   * @param {UUID} id - The ID of the world to remove.
+   * @returns {Promise<void>} A Promise that resolves when the world is removed.
+   */
+  async removeWorld(id) {
+    return this.withDatabase(async () => {
+      await this.db.delete(worldTable).where(eq(worldTable.id, id));
+    });
+  }
+  /**
+   * Asynchronously creates a new task in the database based on the provided parameters.
+   * @param {Task} task - The task object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created task.
+   */
+  async createTask(task) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const now = /* @__PURE__ */ new Date();
+        const metadata = task.metadata || {};
+        const values = {
+          id: task.id,
+          name: task.name,
+          description: task.description,
+          roomId: task.roomId,
+          worldId: task.worldId,
+          tags: task.tags,
+          metadata,
+          createdAt: now,
+          updatedAt: now,
+          agentId: this.agentId
+        };
+        const result = await this.db.insert(taskTable).values(values).returning({ id: taskTable.id });
+        return result[0].id;
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves tasks based on specified parameters.
+   * @param params Object containing optional roomId and tags to filter tasks
+   * @returns Promise resolving to an array of Task objects
+   */
+  async getTasks(params) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        let query = this.db.select().from(taskTable).where(eq(taskTable.agentId, this.agentId));
+        if (params.roomId) {
+          query = query.where(eq(taskTable.roomId, params.roomId));
+        }
+        if (params.tags && params.tags.length > 0) {
+          const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
+          query = query.where(sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`);
+        }
+        const result = await query;
+        return result.map((row) => ({
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags,
+          metadata: row.metadata
+        }));
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves a specific task by its name.
+   * @param name The name of the task to retrieve
+   * @returns Promise resolving to the Task object if found, null otherwise
+   */
+  async getTasksByName(name) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.name, name), eq(taskTable.agentId, this.agentId)));
+        return result.map((row) => ({
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags || [],
+          metadata: row.metadata || {}
+        }));
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves a specific task by its ID.
+   * @param id The UUID of the task to retrieve
+   * @returns Promise resolving to the Task object if found, null otherwise
+   */
+  async getTask(id) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))).limit(1);
+        if (result.length === 0) {
+          return null;
+        }
+        const row = result[0];
+        return {
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags || [],
+          metadata: row.metadata || {}
+        };
+      });
+    });
+  }
+  /**
+   * Asynchronously updates an existing task in the database.
+   * @param id The UUID of the task to update
+   * @param task Partial Task object containing the fields to update
+   * @returns Promise resolving when the update is complete
+   */
+  async updateTask(id, task) {
+    await this.withRetry(async () => {
+      await this.withDatabase(async () => {
+        const updateValues = {};
+        if (task.name !== void 0) updateValues.name = task.name;
+        if (task.description !== void 0) updateValues.description = task.description;
+        if (task.roomId !== void 0) updateValues.roomId = task.roomId;
+        if (task.worldId !== void 0) updateValues.worldId = task.worldId;
+        if (task.tags !== void 0) updateValues.tags = task.tags;
+        task.updatedAt = Date.now();
+        if (task.metadata) {
+          const currentTask = await this.getTask(id);
+          if (currentTask) {
+            const currentMetadata = currentTask.metadata || {};
+            const newMetadata = {
+              ...currentMetadata,
+              ...task.metadata
+            };
+            updateValues.metadata = newMetadata;
+          } else {
+            updateValues.metadata = {
+              ...task.metadata
+            };
+          }
+        }
+        await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
+      });
+    });
+  }
+  /**
+   * Asynchronously deletes a task from the database.
+   * @param id The UUID of the task to delete
+   * @returns Promise resolving when the deletion is complete
+   */
+  async deleteTask(id) {
+    await this.withRetry(async () => {
+      await this.withDatabase(async () => {
+        await this.db.delete(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves group chat memories from all rooms under a given server.
+   * It fetches all room IDs associated with the `serverId`, then retrieves memories
+   * from those rooms in descending order (latest to oldest), with an optional count limit.
+   *
+   * @param {Object} params - Parameters for fetching memories.
+   * @param {UUID} params.serverId - The server ID to fetch memories for.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @returns {Promise<Memory[]>} - A promise that resolves to an array of memory objects.
+   */
+  async getMemoriesByServerId(params) {
+    return this.withDatabase(async () => {
+      const roomIdsResult = await this.db.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, params.serverId));
+      if (roomIdsResult.length === 0) return [];
+      const roomIds = roomIdsResult.map((row) => row.roomId);
+      const query = this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(inArray(memoryTable.roomId, roomIds)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.count ? await query.limit(params.count) : await query;
+      return rows.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0
+      }));
+    });
+  }
+  /**
+   * Asynchronously deletes all rooms associated with a specific serverId.
+   * @param {UUID} serverId - The server ID to delete rooms for.
+   * @returns {Promise<void>} A Promise that resolves when the rooms are deleted.
+   */
+  async deleteRoomsByServerId(serverId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        const roomIdsResult = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, serverId));
+        if (roomIdsResult.length === 0) return;
+        const roomIds = roomIdsResult.map((row) => row.roomId);
+        await tx.delete(embeddingTable).where(
+          inArray(
+            embeddingTable.memoryId,
+            tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds))
+          )
+        );
+        await tx.delete(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+        await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+        await tx.delete(logTable).where(inArray(logTable.roomId, roomIds));
+        await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
+      });
+      logger.debug("Rooms and related logs deleted successfully for server:", {
+        serverId
+      });
+    });
+  }
+};
+
+// src/pglite/adapter.ts
+var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
+  static {
+    __name(this, "PgliteDatabaseAdapter");
+  }
+  manager;
+  embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Constructor for creating an instance of a class.
+   * @param {UUID} agentId - The unique identifier for the agent.
+   * @param {PGliteClientManager} manager - The manager for the PGlite client.
+   */
+  constructor(agentId, manager) {
+    super(agentId);
+    this.manager = manager;
+    this.db = drizzle(this.manager.getConnection());
+  }
+  /**
+   * Asynchronously runs the provided database operation while checking if the database manager is currently shutting down.
+   * If the database manager is shutting down, a warning is logged and null is returned.
+   *
+   * @param {Function} operation - The database operation to be performed.
+   * @returns {Promise<T>} A promise that resolves with the result of the database operation.
+   */
+  async withDatabase(operation) {
+    if (this.manager.isShuttingDown()) {
+      logger2.warn("Database is shutting down");
+      return null;
+    }
+    return operation();
+  }
+  /**
+   * Asynchronously initializes the database by running migrations using the manager.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the database initialization is complete.
+   */
+  async init() {
+    try {
+      await this.manager.runMigrations();
+    } catch (error) {
+      logger2.error("Failed to initialize database:", error);
+      throw error;
+    }
+  }
+  /**
+   * Asynchronously closes the manager.
+   */
+  async close() {
+    await this.manager.close();
+  }
+};
+
+// src/pg/adapter.ts
+import { logger as logger3 } from "@elizaos/core";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
+  /**
+   * Constructor for creating a new instance of a class.
+   * @param {UUID} agentId - The unique identifier for the agent.
+   * @param {PostgresConnectionManager} manager - The Postgres connection manager for the instance.
+   */
+  constructor(agentId, manager) {
+    super(agentId);
+    this.manager = manager;
+    this.manager = manager;
+  }
+  static {
+    __name(this, "PgDatabaseAdapter");
+  }
+  embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Executes the provided operation with a database connection.
+   *
+   * @template T
+   * @param {() => Promise<T>} operation - The operation to be executed with the database connection.
+   * @returns {Promise<T>} A promise that resolves with the result of the operation.
+   */
+  async withDatabase(operation) {
+    return await this.withRetry(async () => {
+      const client = await this.manager.getClient();
+      try {
+        const db = drizzle2(client);
+        this.db = db;
+        return await operation();
+      } finally {
+        client.release();
+      }
+    });
+  }
+  /**
+   * Asynchronously initializes the PgDatabaseAdapter by running migrations using the manager.
+   * Logs a success message if initialization is successful, otherwise logs an error message.
+   *
+   * @returns {Promise<void>} A promise that resolves when initialization is complete.
+   */
+  async init() {
+    try {
+      await this.manager.runMigrations();
+      logger3.debug("PgDatabaseAdapter initialized successfully");
+    } catch (error) {
+      logger3.error("Failed to initialize PgDatabaseAdapter:", error);
+      throw error;
+    }
+  }
+  /**
+   * Asynchronously closes the manager associated with this instance.
+   *
+   * @returns A Promise that resolves once the manager is closed.
+   */
+  async close() {
+    await this.manager.close();
+  }
+};
+
+// src/index.ts
+var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
+var globalSymbols = global;
+if (!globalSymbols[GLOBAL_SINGLETONS]) {
+  globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
+function expandTildePath(filepath) {
+  if (filepath && typeof filepath === "string" && filepath.startsWith("~")) {
+    return filepath.replace(/^~/, os.homedir());
+  }
+  return filepath;
+}
+__name(expandTildePath, "expandTildePath");
+function createDatabaseAdapter(config, agentId) {
+  if (config.dataDir) {
+    config.dataDir = expandTildePath(config.dataDir);
+  }
+  if (config.postgresUrl) {
+    if (!globalSingletons.postgresConnectionManager) {
+      globalSingletons.postgresConnectionManager = new PostgresConnectionManager(
+        config.postgresUrl
+      );
+    }
+    return new PgDatabaseAdapter(agentId, globalSingletons.postgresConnectionManager);
+  }
+  const dataDir = config.dataDir ?? "./elizadb";
+  if (!globalSingletons.pgLiteClientManager) {
+    globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
+  }
+  return new PgliteDatabaseAdapter(agentId, globalSingletons.pgLiteClientManager);
+}
+__name(createDatabaseAdapter, "createDatabaseAdapter");
+var sqlPlugin = {
+  name: "sql",
+  description: "SQL database adapter plugin using Drizzle ORM",
+  init: /* @__PURE__ */ __name(async (_, runtime) => {
+    const config = {
+      dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
+      postgresUrl: runtime.getSetting("POSTGRES_URL")
+    };
+    try {
+      const db = createDatabaseAdapter(config, runtime.agentId);
+      logger4.success("Database connection established successfully");
+      runtime.registerDatabaseAdapter(db);
+    } catch (error) {
+      logger4.error("Failed to initialize database:", error);
+      throw error;
+    }
+  }, "init")
+};
+var index_default = sqlPlugin;
+export {
+  createDatabaseAdapter,
+  index_default as default
+};
 //# sourceMappingURL=index.js.map