@voltagent/libsql 1.0.14 → 2.0.0

package/dist/edge.mjs

@@ -0,0 +1,2167 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/memory-v2-adapter-edge.ts
+import { createClient } from "@libsql/client/web";
+import { AgentRegistry } from "@voltagent/core";
+import { createPinoLogger } from "@voltagent/logger";
+
+// src/memory-core.ts
+import { ConversationAlreadyExistsError, ConversationNotFoundError } from "@voltagent/core";
+import { safeStringify } from "@voltagent/internal";
+var LibSQLMemoryCore = class {
+  static {
+    __name(this, "LibSQLMemoryCore");
+  }
+  client;
+  tablePrefix;
+  initialized = false;
+  logger;
+  maxRetries;
+  retryDelayMs;
+  url;
+  constructor(client, url, options, logger) {
+    this.client = client;
+    this.url = url;
+    this.tablePrefix = options.tablePrefix ?? "voltagent_memory";
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 100;
+    this.logger = logger;
+    this.logger.debug("LibSQL Memory adapter core initialized", { url: this.url });
+  }
+  /**
+   * Execute a database operation with retry logic
+   */
+  async executeWithRetry(operation, operationName) {
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (error?.code === "SQLITE_BUSY" || error?.message?.includes("SQLITE_BUSY") || error?.message?.includes("database is locked")) {
+          const delay = this.retryDelayMs * 2 ** attempt;
+          this.logger.debug(
+            `Database busy, retrying ${operationName} (attempt ${attempt + 1}/${this.maxRetries}) after ${delay}ms`
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          throw error;
+        }
+      }
+    }
+    this.logger.error(
+      `Failed to execute ${operationName} after ${this.maxRetries} attempts`,
+      lastError
+    );
+    throw lastError;
+  }
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const usersTable = `${this.tablePrefix}_users`;
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const stepsTable = `${this.tablePrefix}_steps`;
+    const isMemoryDb = this.url === ":memory:" || this.url.includes("mode=memory");
+    if (!isMemoryDb && (this.url.startsWith("file:") || this.url.startsWith("libsql:"))) {
+      try {
+        await this.client.execute("PRAGMA journal_mode=WAL");
+        this.logger.debug("Set PRAGMA journal_mode=WAL");
+      } catch (err) {
+        this.logger.debug("Failed to set PRAGMA journal_mode=WAL (non-critical)", { err });
+      }
+    }
+    try {
+      await this.client.execute("PRAGMA busy_timeout=5000");
+      this.logger.debug("Set PRAGMA busy_timeout=5000");
+    } catch (err) {
+      this.logger.debug("Failed to set PRAGMA busy_timeout (non-critical)", { err });
+    }
+    try {
+      await this.client.execute("PRAGMA foreign_keys=ON");
+      this.logger.debug("Set PRAGMA foreign_keys=ON");
+    } catch (err) {
+      this.logger.debug("Failed to set PRAGMA foreign_keys (non-critical)", { err });
+    }
+    this.logger.debug("Applied PRAGMA settings for better concurrency");
+    await this.executeWithRetry(async () => {
+      await this.client.batch([
+        `CREATE TABLE IF NOT EXISTS ${usersTable} (
+        id TEXT PRIMARY KEY,
+        metadata TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      )`,
+        `CREATE TABLE IF NOT EXISTS ${conversationsTable} (
+        id TEXT PRIMARY KEY,
+        resource_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        metadata TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+        `CREATE TABLE IF NOT EXISTS ${messagesTable} (
+        conversation_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        parts TEXT NOT NULL,
+        metadata TEXT,
+        format_version INTEGER DEFAULT 2,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, message_id)
+      )`,
+        `CREATE TABLE IF NOT EXISTS ${workflowStatesTable} (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL,
+        workflow_name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        suspension TEXT,
+        events TEXT,
+        output TEXT,
+        cancellation TEXT,
+        user_id TEXT,
+        conversation_id TEXT,
+        metadata TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`,
+        `CREATE TABLE IF NOT EXISTS ${stepsTable} (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        agent_name TEXT,
+        operation_id TEXT,
+        step_index INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT,
+        arguments TEXT,
+        result TEXT,
+        usage TEXT,
+        sub_agent_id TEXT,
+        sub_agent_name TEXT,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES ${conversationsTable}(id) ON DELETE CASCADE
+      )`,
+        `CREATE INDEX IF NOT EXISTS idx_${conversationsTable}_user_id ON ${conversationsTable}(user_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${conversationsTable}_resource_id ON ${conversationsTable}(resource_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${messagesTable}_conversation_id ON ${messagesTable}(conversation_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${messagesTable}_created_at ON ${messagesTable}(created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_${workflowStatesTable}_workflow_id ON ${workflowStatesTable}(workflow_id)`,
+        `CREATE INDEX IF NOT EXISTS idx_${workflowStatesTable}_status ON ${workflowStatesTable}(status)`,
+        `CREATE INDEX IF NOT EXISTS idx_${stepsTable}_conversation ON ${stepsTable}(conversation_id, step_index)`,
+        `CREATE INDEX IF NOT EXISTS idx_${stepsTable}_operation ON ${stepsTable}(conversation_id, operation_id)`
+      ]);
+    }, "initialize database schema");
+    await this.addV2ColumnsToMessagesTable();
+    await this.migrateDefaultUserIds();
+    await this.addWorkflowStateColumns();
+    this.initialized = true;
+    this.logger.debug("Database schema initialized");
+  }
+  async addV2ColumnsToMessagesTable() {
+    const messagesTableName = `${this.tablePrefix}_messages`;
+    try {
+      const tableInfo = await this.client.execute(`PRAGMA table_info(${messagesTableName})`);
+      const columns = tableInfo.rows.map((row) => row.name);
+      if (!columns.includes("parts")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN parts TEXT`);
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("metadata")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN metadata TEXT`);
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("format_version")) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN format_version INTEGER DEFAULT 2`
+          );
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("user_id")) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN user_id TEXT NOT NULL DEFAULT 'default'`
+          );
+        } catch (_e) {
+        }
+      }
+      const contentInfo = tableInfo.rows.find((row) => row.name === "content");
+      if (contentInfo && contentInfo.notnull === 1) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${messagesTableName} ADD COLUMN content_temp TEXT`
+          );
+          await this.client.execute(
+            `UPDATE ${messagesTableName} SET content_temp = content WHERE content IS NOT NULL`
+          );
+          try {
+            await this.client.execute(`ALTER TABLE ${messagesTableName} DROP COLUMN content`);
+            await this.client.execute(
+              `ALTER TABLE ${messagesTableName} RENAME COLUMN content_temp TO content`
+            );
+          } catch (_) {
+          }
+        } catch (_) {
+        }
+      }
+      const typeInfo = tableInfo.rows.find((row) => row.name === "type");
+      if (typeInfo && typeInfo.notnull === 1) {
+        try {
+          await this.client.execute(`ALTER TABLE ${messagesTableName} ADD COLUMN type_temp TEXT`);
+          await this.client.execute(
+            `UPDATE ${messagesTableName} SET type_temp = type WHERE type IS NOT NULL`
+          );
+          try {
+            await this.client.execute(`ALTER TABLE ${messagesTableName} DROP COLUMN type`);
+            await this.client.execute(
+              `ALTER TABLE ${messagesTableName} RENAME COLUMN type_temp TO type`
+            );
+          } catch (_) {
+          }
+        } catch (_) {
+        }
+      }
+    } catch (_) {
+    }
+  }
+  async migrateDefaultUserIds() {
+    const messagesTableName = `${this.tablePrefix}_messages`;
+    const conversationsTableName = `${this.tablePrefix}_conversations`;
+    try {
+      const checkResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${messagesTableName} WHERE user_id = 'default'`,
+        args: []
+      });
+      const defaultCount = checkResult.rows[0]?.count || 0;
+      if (defaultCount === 0) {
+        return;
+      }
+      this.logger.debug(`Found ${defaultCount} messages with default user_id, starting migration`);
+      await this.executeWithRetry(async () => {
+        const result = await this.client.execute({
+          sql: `UPDATE ${messagesTableName}
+                SET user_id = (
+                  SELECT c.user_id
+                  FROM ${conversationsTableName} c
+                  WHERE c.id = ${messagesTableName}.conversation_id
+                )
+                WHERE user_id = 'default'
+                AND EXISTS (
+                  SELECT 1
+                  FROM ${conversationsTableName} c
+                  WHERE c.id = ${messagesTableName}.conversation_id
+                )`,
+          args: []
+        });
+        const updatedCount = result.rowsAffected || 0;
+        this.logger.info(
+          `Successfully migrated ${updatedCount} messages from default user_id to actual user_ids`
+        );
+        const remainingResult = await this.client.execute({
+          sql: `SELECT COUNT(*) as count FROM ${messagesTableName} WHERE user_id = 'default'`,
+          args: []
+        });
+        const remainingCount = remainingResult.rows[0]?.count || 0;
+        if (remainingCount > 0) {
+          this.logger.warn(
+            `${remainingCount} messages still have default user_id (possibly orphaned messages without valid conversations)`
+          );
+        }
+      }, "migrate default user_ids");
+    } catch (error) {
+      this.logger.error("Failed to migrate default user_ids", error);
+    }
+  }
+  async addWorkflowStateColumns() {
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    try {
+      const tableInfo = await this.client.execute(`PRAGMA table_info(${workflowStatesTable})`);
+      const columns = tableInfo.rows.map((row) => row.name);
+      if (!columns.includes("events")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${workflowStatesTable} ADD COLUMN events TEXT`);
+          this.logger.debug("Added 'events' column to workflow_states table");
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("output")) {
+        try {
+          await this.client.execute(`ALTER TABLE ${workflowStatesTable} ADD COLUMN output TEXT`);
+          this.logger.debug("Added 'output' column to workflow_states table");
+        } catch (_e) {
+        }
+      }
+      if (!columns.includes("cancellation")) {
+        try {
+          await this.client.execute(
+            `ALTER TABLE ${workflowStatesTable} ADD COLUMN cancellation TEXT`
+          );
+          this.logger.debug("Added 'cancellation' column to workflow_states table");
+        } catch (_e) {
+        }
+      }
+    } catch (error) {
+      this.logger.warn("Failed to add workflow state columns (non-critical)", error);
+    }
+  }
+  // ============================================================================
+  // Message Operations
+  // ============================================================================
+  async addMessage(message, userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversation = await this.getConversation(conversationId);
+    if (!conversation) {
+      throw new ConversationNotFoundError(conversationId);
+    }
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `INSERT INTO ${messagesTable} (conversation_id, message_id, user_id, role, parts, metadata, format_version, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(conversation_id, message_id) DO UPDATE SET
+              user_id = excluded.user_id,
+              role = excluded.role,
+              parts = excluded.parts,
+              metadata = excluded.metadata,
+              format_version = excluded.format_version`,
+        args: [
+          conversationId,
+          message.id,
+          userId,
+          message.role,
+          safeStringify(message.parts),
+          message.metadata ? safeStringify(message.metadata) : null,
+          2,
+          (/* @__PURE__ */ new Date()).toISOString()
+        ]
+      });
+    }, "add message");
+  }
+  async addMessages(messages, userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversation = await this.getConversation(conversationId);
+    if (!conversation) {
+      throw new ConversationNotFoundError(conversationId);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.executeWithRetry(async () => {
+      await this.client.batch(
+        messages.map((message) => ({
+          sql: `INSERT INTO ${messagesTable} (conversation_id, message_id, user_id, role, parts, metadata, format_version, created_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+              ON CONFLICT(conversation_id, message_id) DO UPDATE SET
+                user_id = excluded.user_id,
+                role = excluded.role,
+                parts = excluded.parts,
+                metadata = excluded.metadata,
+                format_version = excluded.format_version`,
+          args: [
+            conversationId,
+            message.id,
+            userId,
+            message.role,
+            safeStringify(message.parts),
+            message.metadata ? safeStringify(message.metadata) : null,
+            2,
+            now
+          ]
+        }))
+      );
+    }, "add batch messages");
+  }
+  async saveConversationSteps(steps) {
+    if (steps.length === 0) return;
+    await this.initialize();
+    const stepsTable = `${this.tablePrefix}_steps`;
+    await this.executeWithRetry(async () => {
+      await this.client.batch(
+        steps.map((step) => {
+          const createdAt = step.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+          return {
+            sql: `INSERT INTO ${stepsTable} (
+              id,
+              conversation_id,
+              user_id,
+              agent_id,
+              agent_name,
+              operation_id,
+              step_index,
+              type,
+              role,
+              content,
+              arguments,
+              result,
+              usage,
+              sub_agent_id,
+              sub_agent_name,
+              created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+              conversation_id = excluded.conversation_id,
+              user_id = excluded.user_id,
+              agent_id = excluded.agent_id,
+              agent_name = excluded.agent_name,
+              operation_id = excluded.operation_id,
+              step_index = excluded.step_index,
+              type = excluded.type,
+              role = excluded.role,
+              content = excluded.content,
+              arguments = excluded.arguments,
+              result = excluded.result,
+              usage = excluded.usage,
+              sub_agent_id = excluded.sub_agent_id,
+              sub_agent_name = excluded.sub_agent_name,
+              created_at = excluded.created_at`,
+            args: [
+              step.id,
+              step.conversationId,
+              step.userId,
+              step.agentId,
+              step.agentName ?? null,
+              step.operationId ?? null,
+              step.stepIndex,
+              step.type,
+              step.role,
+              step.content ?? null,
+              step.arguments ? safeStringify(step.arguments) : null,
+              step.result ? safeStringify(step.result) : null,
+              step.usage ? safeStringify(step.usage) : null,
+              step.subAgentId ?? null,
+              step.subAgentName ?? null,
+              createdAt
+            ]
+          };
+        })
+      );
+    }, "save conversation steps");
+  }
+  async getMessages(userId, conversationId, options) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const { limit, before, after, roles } = options || {};
+    let sql = `SELECT * FROM ${messagesTable}
+               WHERE conversation_id = ? AND user_id = ?`;
+    const args = [conversationId, userId];
+    if (roles && roles.length > 0) {
+      const placeholders = roles.map(() => "?").join(",");
+      sql += ` AND role IN (${placeholders})`;
+      args.push(...roles);
+    }
+    if (before) {
+      sql += " AND created_at < ?";
+      args.push(before.toISOString());
+    }
+    if (after) {
+      sql += " AND created_at > ?";
+      args.push(after.toISOString());
+    }
+    sql += " ORDER BY created_at ASC";
+    if (limit && limit > 0) {
+      sql += " LIMIT ?";
+      args.push(limit);
+    }
+    const result = await this.client.execute({ sql, args });
+    return result.rows.map((row) => {
+      let parts;
+      if (row.parts !== void 0 && row.parts !== null) {
+        try {
+          parts = JSON.parse(row.parts);
+        } catch {
+          parts = [];
+        }
+      } else if (row.content !== void 0 && row.content !== null) {
+        try {
+          const content = JSON.parse(row.content);
+          if (typeof content === "string") {
+            parts = [{ type: "text", text: content }];
+          } else if (Array.isArray(content)) {
+            parts = content;
+          } else {
+            parts = [];
+          }
+        } catch {
+          parts = [{ type: "text", text: row.content }];
+        }
+      } else {
+        parts = [];
+      }
+      const metadata = row.metadata ? JSON.parse(row.metadata) : {};
+      return {
+        id: row.message_id,
+        role: row.role,
+        parts,
+        metadata: {
+          ...metadata,
+          createdAt: row.created_at ? new Date(row.created_at) : void 0
+        }
+      };
+    });
+  }
+  async getConversationSteps(userId, conversationId, options) {
+    await this.initialize();
+    const stepsTable = `${this.tablePrefix}_steps`;
+    const limit = options?.limit && options.limit > 0 ? options.limit : void 0;
+    let sql = `SELECT * FROM ${stepsTable} WHERE conversation_id = ? AND user_id = ?`;
+    const args = [conversationId, userId];
+    if (options?.operationId) {
+      sql += " AND operation_id = ?";
+      args.push(options.operationId);
+    }
+    sql += " ORDER BY step_index ASC";
+    if (limit !== void 0) {
+      sql += " LIMIT ?";
+      args.push(limit);
+    }
+    const result = await this.client.execute({ sql, args });
+    const parseJsonField = /* @__PURE__ */ __name((value) => {
+      if (typeof value !== "string" || value.length === 0) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(value);
+      } catch {
+        return void 0;
+      }
+    }, "parseJsonField");
+    return result.rows.map((row) => ({
+      id: row.id,
+      conversationId: row.conversation_id,
+      userId: row.user_id,
+      agentId: row.agent_id,
+      agentName: row.agent_name ?? void 0,
+      operationId: row.operation_id ?? void 0,
+      stepIndex: typeof row.step_index === "number" ? row.step_index : Number(row.step_index ?? 0),
+      type: row.type,
+      role: row.role,
+      content: row.content ?? void 0,
+      arguments: parseJsonField(row.arguments),
+      result: parseJsonField(row.result),
+      usage: parseJsonField(row.usage),
+      subAgentId: row.sub_agent_id ?? void 0,
+      subAgentName: row.sub_agent_name ?? void 0,
+      createdAt: row.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  async clearMessages(userId, conversationId) {
+    await this.initialize();
+    const messagesTable = `${this.tablePrefix}_messages`;
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const stepsTable = `${this.tablePrefix}_steps`;
+    if (conversationId) {
+      await this.client.execute({
+        sql: `DELETE FROM ${messagesTable} WHERE conversation_id = ? AND user_id = ?`,
+        args: [conversationId, userId]
+      });
+      await this.client.execute({
+        sql: `DELETE FROM ${stepsTable} WHERE conversation_id = ? AND user_id = ?`,
+        args: [conversationId, userId]
+      });
+    } else {
+      await this.client.execute({
+        sql: `DELETE FROM ${messagesTable}
+              WHERE conversation_id IN (
+                SELECT id FROM ${conversationsTable} WHERE user_id = ?
+              )`,
+        args: [userId]
+      });
+      await this.client.execute({
+        sql: `DELETE FROM ${stepsTable}
+              WHERE conversation_id IN (
+                SELECT id FROM ${conversationsTable} WHERE user_id = ?
+              )`,
+        args: [userId]
+      });
+    }
+  }
+  // ============================================================================
+  // Conversation Operations
+  // ============================================================================
+  async createConversation(input) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const existing = await this.getConversation(input.id);
+    if (existing) {
+      throw new ConversationAlreadyExistsError(input.id);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `INSERT INTO ${conversationsTable} (id, resource_id, user_id, title, metadata, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          input.id,
+          input.resourceId,
+          input.userId,
+          input.title,
+          safeStringify(input.metadata || {}),
+          now,
+          now
+        ]
+      });
+    }, "create conversation");
+    return {
+      id: input.id,
+      userId: input.userId,
+      resourceId: input.resourceId,
+      title: input.title,
+      metadata: input.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  async getConversation(id) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${conversationsTable} WHERE id = ?`,
+      args: [id]
+    });
+    if (result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  async getConversations(resourceId) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${conversationsTable} WHERE resource_id = ? ORDER BY updated_at DESC`,
+      args: [resourceId]
+    });
+    return result.rows.map((row) => ({
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  async getConversationsByUserId(userId, options) {
+    return this.queryConversations({ ...options, userId });
+  }
+  async queryConversations(options) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    let sql = `SELECT * FROM ${conversationsTable} WHERE 1=1`;
+    const args = [];
+    if (options.userId) {
+      sql += " AND user_id = ?";
+      args.push(options.userId);
+    }
+    if (options.resourceId) {
+      sql += " AND resource_id = ?";
+      args.push(options.resourceId);
+    }
+    const orderBy = options.orderBy || "updated_at";
+    const orderDirection = options.orderDirection || "DESC";
+    sql += ` ORDER BY ${orderBy} ${orderDirection}`;
+    if (options.limit) {
+      sql += " LIMIT ?";
+      args.push(options.limit);
+    }
+    if (options.offset) {
+      sql += " OFFSET ?";
+      args.push(options.offset);
+    }
+    const result = await this.client.execute({ sql, args });
+    return result.rows.map((row) => ({
+      id: row.id,
+      userId: row.user_id,
+      resourceId: row.resource_id,
+      title: row.title,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {},
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  async updateConversation(id, updates) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    const conversation = await this.getConversation(id);
+    if (!conversation) {
+      throw new ConversationNotFoundError(id);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fieldsToUpdate = ["updated_at = ?"];
+    const args = [now];
+    if (updates.title !== void 0) {
+      fieldsToUpdate.push("title = ?");
+      args.push(updates.title);
+    }
+    if (updates.resourceId !== void 0) {
+      fieldsToUpdate.push("resource_id = ?");
+      args.push(updates.resourceId);
+    }
+    if (updates.metadata !== void 0) {
+      fieldsToUpdate.push("metadata = ?");
+      args.push(safeStringify(updates.metadata));
+    }
+    args.push(id);
+    await this.client.execute({
+      sql: `UPDATE ${conversationsTable} SET ${fieldsToUpdate.join(", ")} WHERE id = ?`,
+      args
+    });
+    const updated = await this.getConversation(id);
+    if (!updated) {
+      throw new Error(`Conversation not found after update: ${id}`);
+    }
+    return updated;
+  }
+  async deleteConversation(id) {
+    await this.initialize();
+    const conversationsTable = `${this.tablePrefix}_conversations`;
+    await this.client.execute({
+      sql: `DELETE FROM ${conversationsTable} WHERE id = ?`,
+      args: [id]
+    });
+  }
+  // ============================================================================
+  // Working Memory Operations
+  // ============================================================================
+  async getWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      return conversation?.metadata?.workingMemory || null;
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0) {
+        const metadata = result.rows[0].metadata ? JSON.parse(result.rows[0].metadata) : {};
+        return metadata.workingMemory || null;
+      }
+    }
+    return null;
+  }
+  async setWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      if (!conversation) {
+        throw new ConversationNotFoundError(params.conversationId);
+      }
+      const metadata = conversation.metadata || {};
+      metadata.workingMemory = params.content;
+      await this.updateConversation(params.conversationId, { metadata });
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0) {
+        const metadata = result.rows[0].metadata ? JSON.parse(result.rows[0].metadata) : {};
+        metadata.workingMemory = params.content;
+        await this.client.execute({
+          sql: `UPDATE ${usersTable} SET metadata = ?, updated_at = ? WHERE id = ?`,
+          args: [safeStringify(metadata), now, params.userId]
+        });
+      } else {
+        await this.client.execute({
+          sql: `INSERT INTO ${usersTable} (id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+          args: [params.userId, safeStringify({ workingMemory: params.content }), now, now]
+        });
+      }
+    }
+  }
+  async deleteWorkingMemory(params) {
+    await this.initialize();
+    if (params.scope === "conversation" && params.conversationId) {
+      const conversation = await this.getConversation(params.conversationId);
+      if (conversation?.metadata?.workingMemory) {
+        const metadata = { ...conversation.metadata };
+        delete metadata.workingMemory;
+        await this.updateConversation(params.conversationId, { metadata });
+      }
+    }
+    if (params.scope === "user" && params.userId) {
+      const usersTable = `${this.tablePrefix}_users`;
+      const result = await this.client.execute({
+        sql: `SELECT metadata FROM ${usersTable} WHERE id = ?`,
+        args: [params.userId]
+      });
+      if (result.rows.length > 0 && result.rows[0].metadata) {
+        const metadata = JSON.parse(result.rows[0].metadata);
+        if (metadata.workingMemory) {
+          delete metadata.workingMemory;
+          await this.client.execute({
+            sql: `UPDATE ${usersTable} SET metadata = ?, updated_at = ? WHERE id = ?`,
+            args: [safeStringify(metadata), (/* @__PURE__ */ new Date()).toISOString(), params.userId]
+          });
+        }
+      }
+    }
+  }
+  // ============================================================================
+  // Workflow State Operations
+  // ============================================================================
+  async getWorkflowState(executionId) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${workflowStatesTable} WHERE id = ?`,
+      args: [executionId]
+    });
+    if (result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name,
+      status: row.status,
+      suspension: row.suspension ? JSON.parse(row.suspension) : void 0,
+      events: row.events ? JSON.parse(row.events) : void 0,
+      output: row.output ? JSON.parse(row.output) : void 0,
+      cancellation: row.cancellation ? JSON.parse(row.cancellation) : void 0,
+      userId: row.user_id,
+      conversationId: row.conversation_id,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+  async queryWorkflowRuns(query) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const conditions = [];
+    const args = [];
+    if (query.workflowId) {
+      conditions.push("workflow_id = ?");
+      args.push(query.workflowId);
+    }
+    if (query.status) {
+      conditions.push("status = ?");
+      args.push(query.status);
+    }
+    if (query.from) {
+      conditions.push("created_at >= ?");
+      args.push(query.from.toISOString());
+    }
+    if (query.to) {
+      conditions.push("created_at <= ?");
+      args.push(query.to.toISOString());
+    }
+    let sql = `SELECT * FROM ${workflowStatesTable}`;
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    sql += " ORDER BY created_at DESC";
+    if (query.limit !== void 0) {
+      sql += " LIMIT ?";
+      args.push(query.limit);
+    }
+    if (query.offset !== void 0) {
+      sql += " OFFSET ?";
+      args.push(query.offset);
+    }
+    const result = await this.client.execute({
+      sql,
+      args
+    });
+    return result.rows.map((row) => ({
+      id: row.id,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name,
+      status: row.status,
+      suspension: row.suspension ? JSON.parse(row.suspension) : void 0,
+      events: row.events ? JSON.parse(row.events) : void 0,
+      output: row.output ? JSON.parse(row.output) : void 0,
+      cancellation: row.cancellation ? JSON.parse(row.cancellation) : void 0,
+      userId: row.user_id,
+      conversationId: row.conversation_id,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    }));
+  }
+  async setWorkflowState(executionId, state) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    await this.client.execute({
+      sql: `INSERT OR REPLACE INTO ${workflowStatesTable}
+            (id, workflow_id, workflow_name, status, suspension, events, output, cancellation, user_id, conversation_id, metadata, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        executionId,
+        state.workflowId,
+        state.workflowName,
+        state.status,
+        state.suspension ? safeStringify(state.suspension) : null,
+        state.events ? safeStringify(state.events) : null,
+        state.output ? safeStringify(state.output) : null,
+        state.cancellation ? safeStringify(state.cancellation) : null,
+        state.userId || null,
+        state.conversationId || null,
+        state.metadata ? safeStringify(state.metadata) : null,
+        state.createdAt.toISOString(),
+        state.updatedAt.toISOString()
+      ]
+    });
+  }
+  async updateWorkflowState(executionId, updates) {
+    await this.initialize();
+    const existing = await this.getWorkflowState(executionId);
+    if (!existing) {
+      throw new Error(`Workflow state ${executionId} not found`);
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.setWorkflowState(executionId, updated);
+  }
+  async getSuspendedWorkflowStates(workflowId) {
+    await this.initialize();
+    const workflowStatesTable = `${this.tablePrefix}_workflow_states`;
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${workflowStatesTable} WHERE workflow_id = ? AND status = 'suspended' ORDER BY created_at DESC`,
+      args: [workflowId]
+    });
+    return result.rows.map((row) => ({
+      id: row.id,
+      workflowId: row.workflow_id,
+      workflowName: row.workflow_name,
+      status: "suspended",
+      suspension: row.suspension ? JSON.parse(row.suspension) : void 0,
+      events: row.events ? JSON.parse(row.events) : void 0,
+      output: row.output ? JSON.parse(row.output) : void 0,
+      cancellation: row.cancellation ? JSON.parse(row.cancellation) : void 0,
+      userId: row.user_id,
+      conversationId: row.conversation_id,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    }));
+  }
+  async close() {
+    this.logger.debug("Closing LibSQL Memory adapter");
+  }
+};
+
+// src/memory-v2-adapter-edge.ts
+var LibSQLMemoryAdapterEdge = class extends LibSQLMemoryCore {
+  static {
+    __name(this, "LibSQLMemoryAdapterEdge");
+  }
+  constructor(options) {
+    if (!options.url) {
+      throw new Error("LibSQLMemoryAdapterEdge requires a url option");
+    }
+    if (options.url.startsWith("file:") || options.url === ":memory:" || !options.url.startsWith("libsql://")) {
+      throw new Error(
+        "LibSQLMemoryAdapterEdge only supports remote Turso URLs (libsql://). File-based databases are not supported in edge environments. Use LibSQLMemoryAdapter from '@voltagent/libsql' for Node.js environments."
+      );
+    }
+    if (!options.authToken) {
+      throw new Error("LibSQLMemoryAdapterEdge requires an authToken for remote connections");
+    }
+    const logger = options.logger || AgentRegistry.getInstance().getGlobalLogger() || createPinoLogger({ name: "libsql-memory-edge", level: options.debug ? "debug" : "info" });
+    const client = createClient({
+      url: options.url,
+      authToken: options.authToken
+    });
+    super(client, options.url, options, logger);
+  }
+};
+
+// src/observability-adapter-edge.ts
+import { createClient as createClient2 } from "@libsql/client/web";
+import { createPinoLogger as createPinoLogger2 } from "@voltagent/logger";
+
+// src/observability-core.ts
+import { safeStringify as safeStringify2 } from "@voltagent/internal/utils";
+var LibSQLObservabilityCore = class {
+  static {
+    __name(this, "LibSQLObservabilityCore");
+  }
+  client;
+  tablePrefix;
+  debug;
+  logger;
+  initialized;
+  maxSpansPerQuery;
+  constructor(client, options, logger) {
+    this.client = client;
+    this.logger = logger;
+    this.tablePrefix = options.tablePrefix || "observability";
+    this.debug = options.debug || false;
+    this.maxSpansPerQuery = options.maxSpansPerQuery || 1e3;
+    this.debugLog("LibSQL observability adapter core initialized", {
+      tablePrefix: this.tablePrefix,
+      debug: this.debug,
+      maxSpansPerQuery: this.maxSpansPerQuery
+    });
+    this.initialized = this.initializeDatabase();
+  }
+  debugLog(message, data) {
+    if (this.debug) {
+      this.logger.debug(`${message}`, data || "");
+    }
+  }
+  async initializeDatabase() {
+    try {
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_spans (
+          span_id TEXT PRIMARY KEY,
+          trace_id TEXT NOT NULL,
+          parent_span_id TEXT,
+          entity_id TEXT,
+          entity_type TEXT,
+          name TEXT NOT NULL,
+          kind INTEGER DEFAULT 0,
+          start_time TEXT NOT NULL,
+          end_time TEXT,
+          duration REAL,
+          status_code INTEGER DEFAULT 0,
+          status_message TEXT,
+          attributes TEXT,
+          events TEXT,
+          links TEXT,
+          resource TEXT,
+          instrumentation_scope TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_trace_id
+        ON ${this.tablePrefix}_spans(trace_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_parent_span_id
+        ON ${this.tablePrefix}_spans(parent_span_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_start_time
+        ON ${this.tablePrefix}_spans(start_time)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_name
+        ON ${this.tablePrefix}_spans(name)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_entity_id
+        ON ${this.tablePrefix}_spans(entity_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_spans_entity_type
+        ON ${this.tablePrefix}_spans(entity_type)
+      `);
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_traces (
+          trace_id TEXT PRIMARY KEY,
+          root_span_id TEXT,
+          entity_id TEXT,
+          entity_type TEXT,
+          start_time TEXT NOT NULL,
+          end_time TEXT,
+          span_count INTEGER DEFAULT 1,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_start_time
+        ON ${this.tablePrefix}_traces(start_time DESC)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_entity_id
+        ON ${this.tablePrefix}_traces(entity_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_traces_entity_type
+        ON ${this.tablePrefix}_traces(entity_type)
+      `);
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${this.tablePrefix}_logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp TEXT NOT NULL,
+          trace_id TEXT,
+          span_id TEXT,
+          trace_flags INTEGER,
+          severity_number INTEGER,
+          severity_text TEXT,
+          body TEXT NOT NULL,
+          attributes TEXT,
+          resource TEXT,
+          instrumentation_scope TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_trace_id
+        ON ${this.tablePrefix}_logs(trace_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_span_id
+        ON ${this.tablePrefix}_logs(span_id)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_timestamp
+        ON ${this.tablePrefix}_logs(timestamp DESC)
+      `);
+      await this.client.execute(`
+        CREATE INDEX IF NOT EXISTS idx_${this.tablePrefix}_logs_severity
+        ON ${this.tablePrefix}_logs(severity_number)
+      `);
+      this.debugLog("Database tables initialized successfully");
+    } catch (error) {
+      this.logger.error("Failed to initialize database tables", { error });
+      throw error;
+    }
+  }
+  async ensureInitialized() {
+    await this.initialized;
+  }
+  async addSpan(span) {
+    await this.ensureInitialized();
+    try {
+      const entityId = span.attributes?.["entity.id"] || null;
+      const entityType = span.attributes?.["entity.type"] || null;
+      await this.client.batch([
+        {
+          sql: `
+            INSERT INTO ${this.tablePrefix}_spans (
+              span_id, trace_id, parent_span_id, entity_id, entity_type, name, kind,
+              start_time, end_time, duration,
+              status_code, status_message,
+              attributes, events, links,
+              resource, instrumentation_scope
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `,
+          args: [
+            span.spanId,
+            span.traceId,
+            span.parentSpanId || null,
+            entityId,
+            entityType,
+            span.name,
+            span.kind,
+            span.startTime,
+            span.endTime || null,
+            span.duration || null,
+            span.status.code,
+            span.status.message || null,
+            safeStringify2(span.attributes),
+            safeStringify2(span.events),
+            span.links ? safeStringify2(span.links) : null,
+            span.resource ? safeStringify2(span.resource) : null,
+            span.instrumentationScope ? safeStringify2(span.instrumentationScope) : null
+          ]
+        },
+        {
+          sql: `
+            INSERT INTO ${this.tablePrefix}_traces (
+              trace_id, root_span_id, entity_id, entity_type, start_time, end_time, span_count
+            ) VALUES (?, ?, ?, ?, ?, ?, 1)
+            ON CONFLICT(trace_id) DO UPDATE SET
+              span_count = span_count + 1,
+              entity_id = COALESCE(excluded.entity_id, entity_id),
+              entity_type = COALESCE(excluded.entity_type, entity_type),
+              start_time = MIN(start_time, excluded.start_time),
+              end_time = MAX(COALESCE(end_time, excluded.end_time), excluded.end_time),
+              updated_at = CURRENT_TIMESTAMP
+          `,
+          args: [
+            span.traceId,
+            span.parentSpanId ? null : span.spanId,
+            entityId,
+            entityType,
+            span.startTime,
+            span.endTime || null
+          ]
+        }
+      ]);
+      this.debugLog("Span added successfully", {
+        spanId: span.spanId,
+        traceId: span.traceId
+      });
+    } catch (error) {
+      this.logger.error("Failed to add span", { error, span });
+      throw error;
+    }
+  }
+  async updateSpan(spanId, updates) {
+    await this.ensureInitialized();
+    try {
+      const setClauses = [];
+      const args = [];
+      if (updates.endTime !== void 0) {
+        setClauses.push("end_time = ?");
+        args.push(updates.endTime);
+      }
+      if (updates.duration !== void 0) {
+        setClauses.push("duration = ?");
+        args.push(updates.duration);
+      }
+      if (updates.status !== void 0) {
+        setClauses.push("status_code = ?, status_message = ?");
+        args.push(updates.status.code, updates.status.message || null);
+      }
+      if (updates.attributes !== void 0) {
+        setClauses.push("attributes = ?");
+        args.push(safeStringify2(updates.attributes));
+      }
+      if (updates.events !== void 0) {
+        setClauses.push("events = ?");
+        args.push(safeStringify2(updates.events));
+      }
+      if (updates.links !== void 0) {
+        setClauses.push("links = ?");
+        args.push(safeStringify2(updates.links));
+      }
+      if (setClauses.length === 0) {
+        return;
+      }
+      setClauses.push("updated_at = CURRENT_TIMESTAMP");
+      args.push(spanId);
+      await this.client.execute({
+        sql: `
+          UPDATE ${this.tablePrefix}_spans
+          SET ${setClauses.join(", ")}
+          WHERE span_id = ?
+        `,
+        args
+      });
+      if (updates.endTime) {
+        const span = await this.getSpan(spanId);
+        if (span) {
+          await this.client.execute({
+            sql: `
+              UPDATE ${this.tablePrefix}_traces
+              SET end_time = MAX(COALESCE(end_time, ?), ?),
+                  updated_at = CURRENT_TIMESTAMP
+              WHERE trace_id = ?
+            `,
+            args: [updates.endTime, updates.endTime, span.traceId]
+          });
+        }
+      }
+      this.debugLog("Span updated successfully", { spanId, updates });
+    } catch (error) {
+      this.logger.error("Failed to update span", { error, spanId, updates });
+      throw error;
+    }
+  }
+  async getSpan(spanId) {
+    await this.ensureInitialized();
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${this.tablePrefix}_spans WHERE span_id = ?`,
+        args: [spanId]
+      });
+      if (result.rows.length === 0) {
+        return null;
+      }
+      return this.rowToSpan(result.rows[0]);
+    } catch (error) {
+      this.logger.error("Failed to get span", { error, spanId });
+      throw error;
+    }
+  }
+  async getTrace(traceId) {
+    await this.ensureInitialized();
+    try {
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_spans
+          WHERE trace_id = ?
+          ORDER BY start_time ASC
+          LIMIT ?
+        `,
+        args: [traceId, this.maxSpansPerQuery]
+      });
+      return result.rows.map((row) => this.rowToSpan(row));
+    } catch (error) {
+      this.logger.error("Failed to get trace", { error, traceId });
+      throw error;
+    }
+  }
+  async listTraces(limit = 100, offset = 0, filter) {
+    await this.ensureInitialized();
+    try {
+      let sql;
+      let args = [];
+      const conditions = [];
+      if (filter?.entityId) {
+        conditions.push("entity_id = ?");
+        args.push(filter.entityId);
+      }
+      if (filter?.entityType) {
+        conditions.push("entity_type = ?");
+        args.push(filter.entityType);
+      }
+      if (conditions.length > 0) {
+        sql = `
+          SELECT trace_id FROM ${this.tablePrefix}_traces
+          WHERE ${conditions.join(" AND ")}
+          ORDER BY start_time DESC
+          LIMIT ? OFFSET ?
+        `;
+        args.push(limit, offset);
+      } else {
+        sql = `
+          SELECT trace_id FROM ${this.tablePrefix}_traces
+          ORDER BY start_time DESC
+          LIMIT ? OFFSET ?
+        `;
+        args = [limit, offset];
+      }
+      const result = await this.client.execute({ sql, args });
+      return result.rows.map((row) => row.trace_id);
+    } catch (error) {
+      this.logger.error("Failed to list traces", { error, limit, offset, filter });
+      throw error;
+    }
+  }
+  async deleteOldSpans(beforeTimestamp) {
+    await this.ensureInitialized();
+    try {
+      const beforeDate = new Date(beforeTimestamp).toISOString();
+      const tracesResult = await this.client.execute({
+        sql: `SELECT DISTINCT trace_id FROM ${this.tablePrefix}_spans WHERE start_time < ?`,
+        args: [beforeDate]
+      });
+      const affectedTraceIds = tracesResult.rows.map((row) => row.trace_id);
+      const deleteResult = await this.client.execute({
+        sql: `DELETE FROM ${this.tablePrefix}_spans WHERE start_time < ?`,
+        args: [beforeDate]
+      });
+      if (affectedTraceIds.length > 0) {
+        for (const traceId of affectedTraceIds) {
+          const countResult = await this.client.execute({
+            sql: `SELECT COUNT(*) as count FROM ${this.tablePrefix}_spans WHERE trace_id = ?`,
+            args: [traceId]
+          });
+          const count = countResult.rows[0].count;
+          if (count === 0) {
+            await this.client.execute({
+              sql: `DELETE FROM ${this.tablePrefix}_traces WHERE trace_id = ?`,
+              args: [traceId]
+            });
+          } else {
+            await this.client.execute({
+              sql: `
+                UPDATE ${this.tablePrefix}_traces
+                SET span_count = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE trace_id = ?
+              `,
+              args: [count, traceId]
+            });
+          }
+        }
+      }
+      const deletedCount = deleteResult.rowsAffected || 0;
+      this.debugLog("Old spans deleted", { deletedCount, beforeDate });
+      return deletedCount;
+    } catch (error) {
+      this.logger.error("Failed to delete old spans", { error, beforeTimestamp });
+      throw error;
+    }
+  }
+  async clear() {
+    await this.ensureInitialized();
+    try {
+      await this.client.batch([
+        { sql: `DELETE FROM ${this.tablePrefix}_spans`, args: [] },
+        { sql: `DELETE FROM ${this.tablePrefix}_traces`, args: [] },
+        { sql: `DELETE FROM ${this.tablePrefix}_logs`, args: [] }
+      ]);
+      this.debugLog("All spans, traces, and logs cleared");
+    } catch (error) {
+      this.logger.error("Failed to clear data", { error });
+      throw error;
+    }
+  }
+  rowToSpan(row) {
+    const span = {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      name: row.name,
+      kind: row.kind,
+      startTime: row.start_time,
+      status: {
+        code: row.status_code
+      },
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      events: row.events ? JSON.parse(row.events) : []
+    };
+    if (row.parent_span_id !== null) {
+      span.parentSpanId = row.parent_span_id;
+    }
+    if (row.end_time !== null) {
+      span.endTime = row.end_time;
+    }
+    if (row.duration !== null) {
+      span.duration = row.duration;
+    }
+    if (row.status_message !== null) {
+      span.status.message = row.status_message;
+    }
+    if (row.links && row.links !== "null") {
+      const links = JSON.parse(row.links);
+      if (links && links.length > 0) {
+        span.links = links;
+      }
+    }
+    if (row.resource && row.resource !== "null") {
+      const resource = JSON.parse(row.resource);
+      if (resource && Object.keys(resource).length > 0) {
+        span.resource = resource;
+      }
+    }
+    if (row.instrumentation_scope && row.instrumentation_scope !== "null") {
+      const scope = JSON.parse(row.instrumentation_scope);
+      if (scope) {
+        span.instrumentationScope = scope;
+      }
+    }
+    return span;
+  }
+  async getStats() {
+    await this.ensureInitialized();
+    try {
+      const [spanCountResult, traceCountResult, timeRangeResult] = await Promise.all([
+        this.client.execute(`SELECT COUNT(*) as count FROM ${this.tablePrefix}_spans`),
+        this.client.execute(`SELECT COUNT(*) as count FROM ${this.tablePrefix}_traces`),
+        this.client.execute(`
+          SELECT MIN(start_time) as oldest, MAX(start_time) as newest
+          FROM ${this.tablePrefix}_spans
+        `)
+      ]);
+      const stats = {
+        spanCount: spanCountResult.rows[0].count,
+        traceCount: traceCountResult.rows[0].count
+      };
+      if (timeRangeResult.rows[0].oldest) {
+        stats.oldestSpan = new Date(timeRangeResult.rows[0].oldest);
+      }
+      if (timeRangeResult.rows[0].newest) {
+        stats.newestSpan = new Date(timeRangeResult.rows[0].newest);
+      }
+      return stats;
+    } catch (error) {
+      this.logger.error("Failed to get stats", { error });
+      throw error;
+    }
+  }
+  async saveLogRecord(logRecord) {
+    await this.ensureInitialized();
+    try {
+      let timestamp;
+      if (Array.isArray(logRecord.hrTime)) {
+        const timeMs = logRecord.hrTime[0] * 1e3 + logRecord.hrTime[1] / 1e6;
+        timestamp = new Date(timeMs).toISOString();
+      } else if (logRecord.timestamp) {
+        timestamp = typeof logRecord.timestamp === "string" ? logRecord.timestamp : new Date(logRecord.timestamp).toISOString();
+      } else {
+        timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      const spanContext = logRecord.spanContext || {};
+      const traceId = spanContext.traceId || null;
+      const spanId = spanContext.spanId || null;
+      const traceFlags = spanContext.traceFlags ?? null;
+      const severityNumber = logRecord.severityNumber ?? null;
+      const severityText = logRecord.severityText || null;
+      const body = typeof logRecord.body === "string" ? logRecord.body : safeStringify2(logRecord.body);
+      const attributes = logRecord.attributes ? safeStringify2(logRecord.attributes) : null;
+      const resource = logRecord.resource?.attributes ? safeStringify2(logRecord.resource.attributes) : null;
+      const instrumentationScope = logRecord.instrumentationLibrary || logRecord.instrumentationScope ? safeStringify2(logRecord.instrumentationLibrary || logRecord.instrumentationScope) : null;
+      await this.client.execute({
+        sql: `
+          INSERT INTO ${this.tablePrefix}_logs (
+            timestamp, trace_id, span_id, trace_flags,
+            severity_number, severity_text, body,
+            attributes, resource, instrumentation_scope
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        args: [
+          timestamp,
+          traceId,
+          spanId,
+          traceFlags,
+          severityNumber,
+          severityText,
+          body,
+          attributes,
+          resource,
+          instrumentationScope
+        ]
+      });
+      this.debugLog("Log record saved successfully", {
+        timestamp,
+        traceId,
+        spanId,
+        severityNumber
+      });
+    } catch (error) {
+      this.logger.error("Failed to save log record", { error, logRecord });
+      throw error;
+    }
+  }
+  async getLogsByTraceId(traceId) {
+    await this.ensureInitialized();
+    try {
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          WHERE trace_id = ?
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
+        args: [traceId, this.maxSpansPerQuery]
+      });
+      return result.rows.map((row) => this.rowToLogRecord(row));
+    } catch (error) {
+      this.logger.error("Failed to get logs by trace ID", { error, traceId });
+      throw error;
+    }
+  }
+  async getLogsBySpanId(spanId) {
+    await this.ensureInitialized();
+    try {
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          WHERE span_id = ?
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
+        args: [spanId, this.maxSpansPerQuery]
+      });
+      return result.rows.map((row) => this.rowToLogRecord(row));
+    } catch (error) {
+      this.logger.error("Failed to get logs by span ID", { error, spanId });
+      throw error;
+    }
+  }
+  async queryLogs(filter) {
+    await this.ensureInitialized();
+    try {
+      const whereClauses = [];
+      const args = [];
+      if (filter.traceId) {
+        whereClauses.push("trace_id = ?");
+        args.push(filter.traceId);
+      }
+      if (filter.spanId) {
+        whereClauses.push("span_id = ?");
+        args.push(filter.spanId);
+      }
+      if (filter.severityNumber !== void 0) {
+        whereClauses.push("severity_number >= ?");
+        args.push(filter.severityNumber);
+      }
+      if (filter.severityText) {
+        whereClauses.push("severity_text = ?");
+        args.push(filter.severityText);
+      }
+      if (filter.instrumentationScope) {
+        whereClauses.push("instrumentation_scope LIKE ?");
+        args.push(`%${filter.instrumentationScope}%`);
+      }
+      if (filter.startTimeMin !== void 0) {
+        const minTime = new Date(filter.startTimeMin).toISOString();
+        whereClauses.push("timestamp >= ?");
+        args.push(minTime);
+      }
+      if (filter.startTimeMax !== void 0) {
+        const maxTime = new Date(filter.startTimeMax).toISOString();
+        whereClauses.push("timestamp <= ?");
+        args.push(maxTime);
+      }
+      if (filter.bodyContains) {
+        whereClauses.push("body LIKE ?");
+        args.push(`%${filter.bodyContains}%`);
+      }
+      const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+      const limit = filter.limit || this.maxSpansPerQuery;
+      args.push(limit);
+      const result = await this.client.execute({
+        sql: `
+          SELECT * FROM ${this.tablePrefix}_logs
+          ${whereClause}
+          ORDER BY timestamp DESC
+          LIMIT ?
+        `,
+        args
+      });
+      const logs = result.rows.map((row) => this.rowToLogRecord(row));
+      if (filter.attributeKey) {
+        const key = filter.attributeKey;
+        return logs.filter((log) => {
+          if (!log.attributes) return false;
+          if (filter.attributeValue !== void 0) {
+            return log.attributes[key] === filter.attributeValue;
+          }
+          return key in log.attributes;
+        });
+      }
+      return logs;
+    } catch (error) {
+      this.logger.error("Failed to query logs", { error, filter });
+      throw error;
+    }
+  }
+  async deleteOldLogs(beforeTimestamp) {
+    await this.ensureInitialized();
+    try {
+      const beforeDate = new Date(beforeTimestamp).toISOString();
+      const result = await this.client.execute({
+        sql: `DELETE FROM ${this.tablePrefix}_logs WHERE timestamp < ?`,
+        args: [beforeDate]
+      });
+      const deletedCount = result.rowsAffected || 0;
+      this.debugLog("Old logs deleted", { deletedCount, beforeDate });
+      return deletedCount;
+    } catch (error) {
+      this.logger.error("Failed to delete old logs", { error, beforeTimestamp });
+      throw error;
+    }
+  }
+  rowToLogRecord(row) {
+    const log = {
+      timestamp: row.timestamp,
+      body: (() => {
+        try {
+          const bodyStr = row.body;
+          if (bodyStr.startsWith("{") || bodyStr.startsWith("[")) {
+            return JSON.parse(bodyStr);
+          }
+        } catch {
+        }
+        return row.body;
+      })()
+    };
+    if (row.trace_id !== null) {
+      log.traceId = row.trace_id;
+    }
+    if (row.span_id !== null) {
+      log.spanId = row.span_id;
+    }
+    if (row.trace_flags !== null) {
+      log.traceFlags = row.trace_flags;
+    }
+    if (row.severity_number !== null) {
+      log.severityNumber = row.severity_number;
+    }
+    if (row.severity_text !== null) {
+      log.severityText = row.severity_text;
+    }
+    if (row.attributes && row.attributes !== "null") {
+      try {
+        const attributes = JSON.parse(row.attributes);
+        if (attributes && Object.keys(attributes).length > 0) {
+          log.attributes = attributes;
+        }
+      } catch {
+      }
+    }
+    if (row.resource && row.resource !== "null") {
+      try {
+        const resource = JSON.parse(row.resource);
+        if (resource && Object.keys(resource).length > 0) {
+          log.resource = resource;
+        }
+      } catch {
+      }
+    }
+    if (row.instrumentation_scope && row.instrumentation_scope !== "null") {
+      try {
+        const scope = JSON.parse(row.instrumentation_scope);
+        if (scope) {
+          log.instrumentationScope = scope;
+        }
+      } catch {
+      }
+    }
+    return log;
+  }
+  getInfo() {
+    return {
+      adapter: this.constructor.name,
+      displayName: "LibSQL Observability Storage",
+      persistent: true,
+      description: "Persists spans and logs to a LibSQL/Turso database for long-term retention."
+    };
+  }
+  async close() {
+    this.debugLog("LibSQL observability adapter closed");
+  }
+};
+
+// src/observability-adapter-edge.ts
+var LibSQLObservabilityAdapterEdge = class extends LibSQLObservabilityCore {
+  static {
+    __name(this, "LibSQLObservabilityAdapterEdge");
+  }
+  constructor(options) {
+    if (!options.url) {
+      throw new Error("LibSQLObservabilityAdapterEdge requires a url option");
+    }
+    if (options.url.startsWith("file:") || options.url === ":memory:" || !options.url.startsWith("libsql://")) {
+      throw new Error(
+        "LibSQLObservabilityAdapterEdge only supports remote Turso URLs (libsql://). File-based databases are not supported in edge environments. Use LibSQLObservabilityAdapter from '@voltagent/libsql' for Node.js environments."
+      );
+    }
+    if (!options.authToken) {
+      throw new Error(
+        "LibSQLObservabilityAdapterEdge requires an authToken for remote connections"
+      );
+    }
+    const logger = options.logger || createPinoLogger2({ name: "libsql-observability-edge" });
+    const client = createClient2({
+      url: options.url,
+      authToken: options.authToken
+    });
+    super(client, options, logger);
+  }
+};
+
+// src/vector-adapter-edge.ts
+import { createClient as createClient3 } from "@libsql/client/web";
+import { createPinoLogger as createPinoLogger3 } from "@voltagent/logger";
+
+// src/vector-core.ts
+import {
+  cosineSimilarity
+} from "@voltagent/core";
+import { safeStringify as safeStringify3 } from "@voltagent/internal";
+var LibSQLVectorCore = class {
+  static {
+    __name(this, "LibSQLVectorCore");
+  }
+  client;
+  tablePrefix;
+  maxVectorDimensions;
+  cacheSize;
+  batchSize;
+  debug;
+  logger;
+  maxRetries;
+  retryDelayMs;
+  initialized = false;
+  vectorCache;
+  dimensions = null;
+  constructor(client, options, logger) {
+    this.client = client;
+    this.tablePrefix = options.tablePrefix ?? "voltagent";
+    this.maxVectorDimensions = options.maxVectorDimensions ?? 1536;
+    this.cacheSize = options.cacheSize ?? 100;
+    this.batchSize = options.batchSize ?? 100;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 100;
+    this.debug = options.debug ?? false;
+    this.logger = logger;
+    this.vectorCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Serialize a vector to binary format
+   * Uses ArrayBuffer/DataView for cross-platform compatibility
+   */
+  serializeVector(vector) {
+    const buffer = new ArrayBuffer(vector.length * 4);
+    const view = new DataView(buffer);
+    for (let i = 0; i < vector.length; i++) {
+      view.setFloat32(i * 4, vector[i], true);
+    }
+    return new Uint8Array(buffer);
+  }
+  /**
+   * Deserialize a vector from binary format
+   */
+  deserializeVector(data) {
+    const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const vector = [];
+    for (let i = 0; i < bytes.length; i += 4) {
+      vector.push(view.getFloat32(i, true));
+    }
+    return vector;
+  }
+  /**
+   * Initialize the database schema
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const tableName = `${this.tablePrefix}_vectors`;
+    try {
+      await this.client.execute(`
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          id TEXT PRIMARY KEY,
+          vector BLOB NOT NULL,
+          dimensions INTEGER NOT NULL,
+          metadata TEXT,
+          content TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await this.client.execute(
+        `CREATE INDEX IF NOT EXISTS idx_${tableName}_created ON ${tableName}(created_at)`
+      );
+      await this.client.execute(
+        `CREATE INDEX IF NOT EXISTS idx_${tableName}_dimensions ON ${tableName}(dimensions)`
+      );
+      this.initialized = true;
+      this.logger.debug("Vector adapter initialized");
+    } catch (error) {
+      this.logger.error("Failed to initialize vector adapter", error);
+      throw error;
+    }
+  }
+  /**
+   * Execute a database operation with retries
+   */
+  async executeWithRetry(operation, context) {
+    let lastError;
+    let delay = this.retryDelayMs;
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`Operation failed (attempt ${attempt}): ${context}`, error);
+        if (attempt < this.maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delay *= 2;
+        }
+      }
+    }
+    this.logger.error(`Operation failed after ${this.maxRetries} attempts: ${context}`, lastError);
+    throw lastError;
+  }
+  async store(id, vector, metadata) {
+    await this.initialize();
+    if (!Array.isArray(vector) || vector.length === 0) {
+      throw new Error("Vector must be a non-empty array");
+    }
+    if (vector.length > this.maxVectorDimensions) {
+      throw new Error(
+        `Vector dimensions (${vector.length}) exceed maximum (${this.maxVectorDimensions})`
+      );
+    }
+    if (this.dimensions === null) {
+      this.dimensions = vector.length;
+    } else if (vector.length !== this.dimensions) {
+      throw new Error(
+        `Vector dimension mismatch. Expected ${this.dimensions}, got ${vector.length}`
+      );
+    }
+    const tableName = `${this.tablePrefix}_vectors`;
+    const serializedVector = this.serializeVector(vector);
+    const metadataJson = metadata ? safeStringify3(metadata) : null;
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `
+          INSERT OR REPLACE INTO ${tableName}
+          (id, vector, dimensions, metadata, updated_at)
+          VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+        `,
+        args: [id, serializedVector, vector.length, metadataJson]
+      });
+    }, `store vector ${id}`);
+    if (this.vectorCache.size >= this.cacheSize) {
+      const firstKey = this.vectorCache.keys().next().value;
+      if (firstKey) this.vectorCache.delete(firstKey);
+    }
+    this.vectorCache.set(id, { id, vector, metadata });
+    this.logger.debug(`Vector stored: ${id} (${vector.length} dimensions)`);
+  }
+  async storeBatch(items) {
+    await this.initialize();
+    if (items.length === 0) return;
+    const tableName = `${this.tablePrefix}_vectors`;
+    for (let i = 0; i < items.length; i += this.batchSize) {
+      const batch = items.slice(i, i + this.batchSize);
+      await this.executeWithRetry(async () => {
+        const stmts = [];
+        for (const item of batch) {
+          if (!Array.isArray(item.vector) || item.vector.length === 0) {
+            throw new Error("Vector must be a non-empty array");
+          }
+          if (this.dimensions === null) {
+            this.dimensions = item.vector.length;
+          } else if (item.vector.length !== this.dimensions) {
+            throw new Error(
+              `Vector dimension mismatch. Expected ${this.dimensions}, got ${item.vector.length}`
+            );
+          }
+          const serializedVector = this.serializeVector(item.vector);
+          const metadataJson = item.metadata ? safeStringify3(item.metadata) : null;
+          const content = item.content ?? null;
+          stmts.push({
+            sql: `INSERT OR REPLACE INTO ${tableName} (id, vector, dimensions, metadata, content, updated_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+            args: [item.id, serializedVector, item.vector.length, metadataJson, content]
+          });
+        }
+        await this.client.batch(stmts, "write");
+      }, `storeBatch ${batch.length} vectors`);
+      this.logger.debug(`Batch of ${batch.length} vectors stored`);
+    }
+  }
+  async search(queryVector, options) {
+    await this.initialize();
+    const { limit = 10, threshold = 0, filter } = options || {};
+    if (this.dimensions !== null && queryVector.length !== this.dimensions) {
+      throw new Error(
+        `Query vector dimension mismatch. Expected ${this.dimensions}, got ${queryVector.length}`
+      );
+    }
+    const tableName = `${this.tablePrefix}_vectors`;
+    let query = `SELECT id, vector, dimensions, metadata, content FROM ${tableName}`;
+    const args = [];
+    if (this.dimensions !== null) {
+      query += " WHERE dimensions = ?";
+      args.push(this.dimensions);
+    }
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute({ sql: query, args }),
+      "search vectors"
+    );
+    const searchResults = [];
+    for (const row of result.rows) {
+      const id = row.id;
+      const vectorBlob = row.vector;
+      const metadataJson = row.metadata;
+      const content = row.content ?? void 0;
+      const metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+      if (filter && !this.matchesFilter(metadata, filter)) {
+        continue;
+      }
+      const vector = this.deserializeVector(vectorBlob);
+      const similarity = cosineSimilarity(queryVector, vector);
+      const score = (similarity + 1) / 2;
+      if (score >= threshold) {
+        searchResults.push({
+          id,
+          vector,
+          metadata,
+          content,
+          score,
+          distance: 1 - similarity
+        });
+      }
+    }
+    searchResults.sort((a, b) => b.score - a.score);
+    return searchResults.slice(0, limit);
+  }
+  matchesFilter(metadata, filter) {
+    if (!metadata) {
+      return false;
+    }
+    for (const [key, value] of Object.entries(filter)) {
+      if (metadata[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async delete(id) {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    await this.executeWithRetry(async () => {
+      await this.client.execute({
+        sql: `DELETE FROM ${tableName} WHERE id = ?`,
+        args: [id]
+      });
+    }, `delete vector ${id}`);
+    this.vectorCache.delete(id);
+    this.logger.debug(`Vector deleted: ${id}`);
+  }
+  async deleteBatch(ids) {
+    await this.initialize();
+    if (ids.length === 0) return;
+    const tableName = `${this.tablePrefix}_vectors`;
+    for (let i = 0; i < ids.length; i += this.batchSize) {
+      const batch = ids.slice(i, i + this.batchSize);
+      const placeholders = batch.map(() => "?").join(",");
+      await this.executeWithRetry(async () => {
+        await this.client.execute({
+          sql: `DELETE FROM ${tableName} WHERE id IN (${placeholders})`,
+          args: batch
+        });
+      }, `deleteBatch ${batch.length} vectors`);
+      for (const id of batch) {
+        this.vectorCache.delete(id);
+      }
+      this.logger.debug(`Batch of ${batch.length} vectors deleted`);
+    }
+  }
+  async clear() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    await this.executeWithRetry(async () => {
+      await this.client.execute(`DELETE FROM ${tableName}`);
+    }, "clear all vectors");
+    this.vectorCache.clear();
+    this.dimensions = null;
+    this.logger.debug("All vectors cleared");
+  }
+  async count() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute(`SELECT COUNT(*) as count FROM ${tableName}`),
+      "count vectors"
+    );
+    const raw = result.rows[0]?.count;
+    if (typeof raw === "bigint") return Number(raw);
+    if (typeof raw === "string") return Number.parseInt(raw, 10) || 0;
+    return raw ?? 0;
+  }
+  async get(id) {
+    await this.initialize();
+    if (this.vectorCache.has(id)) {
+      const cached = this.vectorCache.get(id);
+      if (cached) {
+        return {
+          ...cached,
+          vector: [...cached.vector],
+          metadata: cached.metadata ? { ...cached.metadata } : void 0
+        };
+      }
+    }
+    const tableName = `${this.tablePrefix}_vectors`;
+    const result = await this.executeWithRetry(
+      async () => await this.client.execute({
+        sql: `SELECT id, vector, metadata, content FROM ${tableName} WHERE id = ?`,
+        args: [id]
+      }),
+      `get vector ${id}`
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    const vectorBlob = row.vector;
+    const metadataJson = row.metadata;
+    const content = row.content;
+    const vector = this.deserializeVector(vectorBlob);
+    const metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+    const item = {
+      id,
+      vector,
+      metadata,
+      content: content ?? void 0
+    };
+    if (this.vectorCache.size >= this.cacheSize) {
+      const firstKey = this.vectorCache.keys().next().value;
+      if (firstKey) this.vectorCache.delete(firstKey);
+    }
+    this.vectorCache.set(id, item);
+    return item;
+  }
+  async close() {
+    this.vectorCache.clear();
+    this.logger.debug("Vector adapter closed");
+  }
+  async getStats() {
+    await this.initialize();
+    const tableName = `${this.tablePrefix}_vectors`;
+    const [countResult, sizeResult] = await Promise.all([
+      this.executeWithRetry(
+        async () => await this.client.execute(
+          `SELECT COUNT(*) as count, MAX(dimensions) as dims FROM ${tableName}`
+        ),
+        "getStats count"
+      ),
+      this.executeWithRetry(
+        async () => await this.client.execute({
+          sql: `SELECT
+              COALESCE(SUM(LENGTH(id)),0) +
+              COALESCE(SUM(LENGTH(vector)),0) +
+              COALESCE(SUM(LENGTH(metadata)),0) +
+              COALESCE(SUM(LENGTH(content)),0) AS size
+            FROM ${tableName}`
+        }),
+        "getStats size"
+      )
+    ]);
+    const row1 = countResult.rows[0];
+    const row2 = sizeResult.rows[0];
+    const countRaw = row1?.count;
+    const dimsRaw = row1?.dims;
+    const sizeRaw = row2?.size;
+    const normalize = /* @__PURE__ */ __name((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number.parseInt(v, 10) || 0 : v ?? 0, "normalize");
+    return {
+      count: normalize(countRaw),
+      dimensions: dimsRaw != null ? normalize(dimsRaw) : this.dimensions,
+      cacheSize: this.vectorCache.size,
+      tableSizeBytes: normalize(sizeRaw)
+    };
+  }
+};
+
+// src/vector-adapter-edge.ts
+var LibSQLVectorAdapterEdge = class extends LibSQLVectorCore {
+  static {
+    __name(this, "LibSQLVectorAdapterEdge");
+  }
+  constructor(options) {
+    if (!options.url) {
+      throw new Error("LibSQLVectorAdapterEdge requires a url option");
+    }
+    if (options.url.startsWith("file:") || options.url === ":memory:" || !options.url.startsWith("libsql://")) {
+      throw new Error(
+        "LibSQLVectorAdapterEdge only supports remote Turso URLs (libsql://). File-based databases are not supported in edge environments. Use LibSQLVectorAdapter from '@voltagent/libsql' for Node.js environments."
+      );
+    }
+    if (!options.authToken) {
+      throw new Error("LibSQLVectorAdapterEdge requires an authToken for remote connections");
+    }
+    const logger = options.logger ?? createPinoLogger3({
+      name: "libsql-vector-adapter-edge",
+      level: options.debug ? "debug" : "info"
+    });
+    const client = createClient3({
+      url: options.url,
+      authToken: options.authToken
+    });
+    super(client, options, logger);
+  }
+};
+export {
+  LibSQLMemoryAdapterEdge as LibSQLMemoryAdapter,
+  LibSQLMemoryAdapterEdge,
+  LibSQLObservabilityAdapterEdge as LibSQLObservabilityAdapter,
+  LibSQLObservabilityAdapterEdge,
+  LibSQLVectorAdapterEdge as LibSQLVectorAdapter,
+  LibSQLVectorAdapterEdge
+};
+//# sourceMappingURL=edge.mjs.map