@huyooo/ai-chat-storage 0.1.0

package/dist/chunk-GCKDCC3O.js

@@ -0,0 +1,678 @@
+// src/adapters/sqlite/index.ts
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import Database from "better-sqlite3";
+
+// src/schema.ts
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  appId: text("app_id"),
+  userId: text("user_id"),
+  title: text("title").notNull(),
+  model: text("model").notNull(),
+  mode: text("mode").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_sessions_tenant").on(table.appId, table.userId),
+  index("idx_sessions_updated").on(table.updatedAt)
+]);
+var messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull(),
+  appId: text("app_id"),
+  userId: text("user_id"),
+  role: text("role").notNull(),
+  content: text("content").notNull(),
+  thinking: text("thinking"),
+  toolCalls: text("tool_calls"),
+  searchResults: text("search_results"),
+  operationIds: text("operation_ids"),
+  timestamp: integer("timestamp", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_messages_session").on(table.sessionId),
+  index("idx_messages_tenant").on(table.appId, table.userId)
+]);
+var operations = sqliteTable("operations", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull(),
+  messageId: text("message_id"),
+  appId: text("app_id"),
+  userId: text("user_id"),
+  command: text("command").notNull(),
+  operationType: text("operation_type").notNull(),
+  affectedFiles: text("affected_files").notNull(),
+  backupPath: text("backup_path"),
+  status: text("status").notNull().default("pending"),
+  errorMessage: text("error_message"),
+  timestamp: integer("timestamp", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_operations_session").on(table.sessionId),
+  index("idx_operations_message").on(table.messageId),
+  index("idx_operations_tenant").on(table.appId, table.userId)
+]);
+var backups = sqliteTable("backups", {
+  id: text("id").primaryKey(),
+  operationId: text("operation_id").notNull(),
+  originalPath: text("original_path").notNull(),
+  backupPath: text("backup_path").notNull(),
+  fileSize: integer("file_size").notNull(),
+  fileHash: text("file_hash").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_backups_operation").on(table.operationId),
+  index("idx_backups_expires").on(table.expiresAt)
+]);
+var trash = sqliteTable("trash", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull(),
+  appId: text("app_id"),
+  userId: text("user_id"),
+  originalPath: text("original_path").notNull(),
+  trashPath: text("trash_path").notNull(),
+  deletedAt: integer("deleted_at", { mode: "timestamp" }).notNull(),
+  autoDeleteAt: integer("auto_delete_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_trash_tenant").on(table.appId, table.userId),
+  index("idx_trash_auto_delete").on(table.autoDeleteAt)
+]);
+var embeddings = sqliteTable("embeddings", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull(),
+  messageId: text("message_id"),
+  appId: text("app_id"),
+  userId: text("user_id"),
+  content: text("content").notNull(),
+  contentType: text("content_type").notNull(),
+  embedding: text("embedding"),
+  // JSON 字符串存储
+  metadata: text("metadata"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_embeddings_session").on(table.sessionId),
+  index("idx_embeddings_tenant").on(table.appId, table.userId)
+]);
+
+// src/adapters/sqlite/base.ts
+import { eq, and } from "drizzle-orm";
+function initSchema(sqlite) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      app_id TEXT,
+      user_id TEXT,
+      title TEXT NOT NULL,
+      model TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      app_id TEXT,
+      user_id TEXT,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      thinking TEXT,
+      tool_calls TEXT,
+      search_results TEXT,
+      operation_ids TEXT,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS operations (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_id TEXT,
+      app_id TEXT,
+      user_id TEXT,
+      command TEXT NOT NULL,
+      operation_type TEXT NOT NULL,
+      affected_files TEXT NOT NULL,
+      backup_path TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      error_message TEXT,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS backups (
+      id TEXT PRIMARY KEY,
+      operation_id TEXT NOT NULL,
+      original_path TEXT NOT NULL,
+      backup_path TEXT NOT NULL,
+      file_size INTEGER NOT NULL,
+      file_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS trash (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      app_id TEXT,
+      user_id TEXT,
+      original_path TEXT NOT NULL,
+      trash_path TEXT NOT NULL,
+      deleted_at INTEGER NOT NULL,
+      auto_delete_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS embeddings (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_id TEXT,
+      app_id TEXT,
+      user_id TEXT,
+      content TEXT NOT NULL,
+      content_type TEXT NOT NULL,
+      embedding TEXT,
+      metadata TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    -- \u7D22\u5F15
+    CREATE INDEX IF NOT EXISTS idx_sessions_tenant ON sessions(app_id, user_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at);
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_tenant ON messages(app_id, user_id);
+    CREATE INDEX IF NOT EXISTS idx_operations_session ON operations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_operations_message ON operations(message_id);
+    CREATE INDEX IF NOT EXISTS idx_backups_operation ON backups(operation_id);
+    CREATE INDEX IF NOT EXISTS idx_backups_expires ON backups(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_trash_tenant ON trash(app_id, user_id);
+    CREATE INDEX IF NOT EXISTS idx_trash_auto_delete ON trash(auto_delete_at);
+    CREATE INDEX IF NOT EXISTS idx_embeddings_session ON embeddings(session_id);
+  `);
+}
+function buildSessionsTenantCondition(ctx) {
+  const conditions = [];
+  if (ctx.appId) conditions.push(eq(sessions.appId, ctx.appId));
+  if (ctx.userId) conditions.push(eq(sessions.userId, ctx.userId));
+  return conditions.length > 0 ? and(...conditions) : void 0;
+}
+function buildMessagesTenantCondition(ctx) {
+  const conditions = [];
+  if (ctx.appId) conditions.push(eq(messages.appId, ctx.appId));
+  if (ctx.userId) conditions.push(eq(messages.userId, ctx.userId));
+  return conditions.length > 0 ? and(...conditions) : void 0;
+}
+function buildOperationsTenantCondition(ctx) {
+  const conditions = [];
+  if (ctx.appId) conditions.push(eq(operations.appId, ctx.appId));
+  if (ctx.userId) conditions.push(eq(operations.userId, ctx.userId));
+  return conditions.length > 0 ? and(...conditions) : void 0;
+}
+function buildTrashTenantCondition(ctx) {
+  const conditions = [];
+  if (ctx.appId) conditions.push(eq(trash.appId, ctx.appId));
+  if (ctx.userId) conditions.push(eq(trash.userId, ctx.userId));
+  return conditions.length > 0 ? and(...conditions) : void 0;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/adapters/sqlite/sessions.ts
+import { eq as eq2, and as and2, desc } from "drizzle-orm";
+function toSessionRecord(row) {
+  return {
+    id: row.id,
+    appId: row.appId,
+    userId: row.userId,
+    title: row.title,
+    model: row.model,
+    mode: row.mode,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function getSessions(db, ctx) {
+  const tenantCondition = buildSessionsTenantCondition(ctx);
+  const rows = db.select().from(sessions).where(tenantCondition).orderBy(desc(sessions.updatedAt)).all();
+  return rows.map(toSessionRecord);
+}
+function getSession(db, id, ctx) {
+  const tenantCondition = buildSessionsTenantCondition(ctx);
+  const condition = tenantCondition ? and2(eq2(sessions.id, id), tenantCondition) : eq2(sessions.id, id);
+  const row = db.select().from(sessions).where(condition).get();
+  return row ? toSessionRecord(row) : null;
+}
+function createSession(db, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const record = {
+    id: input.id,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    title: input.title,
+    model: input.model,
+    mode: input.mode,
+    createdAt: now,
+    updatedAt: now
+  };
+  db.insert(sessions).values({
+    id: record.id,
+    appId: record.appId,
+    userId: record.userId,
+    title: record.title,
+    model: record.model,
+    mode: record.mode,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  }).run();
+  return record;
+}
+function updateSession(db, id, data, ctx) {
+  const tenantCondition = buildSessionsTenantCondition(ctx);
+  const condition = tenantCondition ? and2(eq2(sessions.id, id), tenantCondition) : eq2(sessions.id, id);
+  const updateData = { updatedAt: /* @__PURE__ */ new Date() };
+  if (data.title !== void 0) updateData.title = data.title;
+  if (data.model !== void 0) updateData.model = data.model;
+  if (data.mode !== void 0) updateData.mode = data.mode;
+  db.update(sessions).set(updateData).where(condition).run();
+}
+function deleteSession(db, id, ctx) {
+  const tenantCondition = buildSessionsTenantCondition(ctx);
+  const condition = tenantCondition ? and2(eq2(sessions.id, id), tenantCondition) : eq2(sessions.id, id);
+  db.delete(sessions).where(condition).run();
+}
+
+// src/adapters/sqlite/messages.ts
+import { eq as eq3, and as and3, gt } from "drizzle-orm";
+function toMessageRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.sessionId,
+    appId: row.appId,
+    userId: row.userId,
+    role: row.role,
+    content: row.content,
+    thinking: row.thinking,
+    toolCalls: row.toolCalls,
+    searchResults: row.searchResults,
+    operationIds: row.operationIds,
+    timestamp: row.timestamp
+  };
+}
+function getMessages(db, sessionId) {
+  const rows = db.select().from(messages).where(eq3(messages.sessionId, sessionId)).orderBy(messages.timestamp).all();
+  return rows.map(toMessageRecord);
+}
+function getMessage(db, id, ctx) {
+  const tenantCondition = buildMessagesTenantCondition(ctx);
+  const condition = tenantCondition ? and3(eq3(messages.id, id), tenantCondition) : eq3(messages.id, id);
+  const row = db.select().from(messages).where(condition).get();
+  return row ? toMessageRecord(row) : null;
+}
+function saveMessage(db, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const record = {
+    id: input.id,
+    sessionId: input.sessionId,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    role: input.role,
+    content: input.content,
+    thinking: input.thinking,
+    toolCalls: input.toolCalls,
+    searchResults: input.searchResults,
+    operationIds: input.operationIds,
+    timestamp: now
+  };
+  db.insert(messages).values({
+    id: record.id,
+    sessionId: record.sessionId,
+    appId: record.appId,
+    userId: record.userId,
+    role: record.role,
+    content: record.content,
+    thinking: record.thinking,
+    toolCalls: record.toolCalls,
+    searchResults: record.searchResults,
+    operationIds: record.operationIds,
+    timestamp: record.timestamp
+  }).run();
+  db.update(sessions).set({ updatedAt: now }).where(eq3(sessions.id, input.sessionId)).run();
+  return record;
+}
+function deleteMessagesAfter(db, sessionId, timestamp) {
+  db.delete(messages).where(and3(
+    eq3(messages.sessionId, sessionId),
+    gt(messages.timestamp, timestamp)
+  )).run();
+}
+function deleteSessionMessages(db, sessionId) {
+  db.delete(messages).where(eq3(messages.sessionId, sessionId)).run();
+}
+
+// src/adapters/sqlite/operations.ts
+import { eq as eq4, and as and4 } from "drizzle-orm";
+function toOperationRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.sessionId,
+    messageId: row.messageId,
+    appId: row.appId,
+    userId: row.userId,
+    command: row.command,
+    operationType: row.operationType,
+    affectedFiles: row.affectedFiles,
+    backupPath: row.backupPath,
+    status: row.status,
+    errorMessage: row.errorMessage,
+    timestamp: row.timestamp
+  };
+}
+function getOperations(db, sessionId) {
+  const rows = db.select().from(operations).where(eq4(operations.sessionId, sessionId)).orderBy(operations.timestamp).all();
+  return rows.map(toOperationRecord);
+}
+function getOperationsByMessage(db, messageId, ctx) {
+  const tenantCondition = buildOperationsTenantCondition(ctx);
+  const condition = tenantCondition ? and4(eq4(operations.messageId, messageId), tenantCondition) : eq4(operations.messageId, messageId);
+  const rows = db.select().from(operations).where(condition).all();
+  return rows.map(toOperationRecord);
+}
+function saveOperation(db, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const record = {
+    id: input.id,
+    sessionId: input.sessionId,
+    messageId: input.messageId,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    command: input.command,
+    operationType: input.operationType,
+    affectedFiles: input.affectedFiles,
+    backupPath: input.backupPath,
+    status: input.status || "pending",
+    errorMessage: null,
+    timestamp: now
+  };
+  db.insert(operations).values({
+    id: record.id,
+    sessionId: record.sessionId,
+    messageId: record.messageId,
+    appId: record.appId,
+    userId: record.userId,
+    command: record.command,
+    operationType: record.operationType,
+    affectedFiles: record.affectedFiles,
+    backupPath: record.backupPath,
+    status: record.status,
+    errorMessage: record.errorMessage,
+    timestamp: record.timestamp
+  }).run();
+  return record;
+}
+function updateOperationStatus(db, id, status, errorMessage) {
+  const updateData = { status };
+  if (errorMessage !== void 0) {
+    updateData.errorMessage = errorMessage;
+  }
+  db.update(operations).set(updateData).where(eq4(operations.id, id)).run();
+}
+function deleteSessionOperations(db, sessionId) {
+  db.delete(operations).where(eq4(operations.sessionId, sessionId)).run();
+}
+
+// src/adapters/sqlite/backups.ts
+import { eq as eq5, lt } from "drizzle-orm";
+function toBackupRecord(row) {
+  return {
+    id: row.id,
+    operationId: row.operationId,
+    originalPath: row.originalPath,
+    backupPath: row.backupPath,
+    fileSize: row.fileSize,
+    fileHash: row.fileHash,
+    createdAt: row.createdAt,
+    expiresAt: row.expiresAt
+  };
+}
+function getBackups(db, operationId) {
+  const rows = db.select().from(backups).where(eq5(backups.operationId, operationId)).all();
+  return rows.map(toBackupRecord);
+}
+function saveBackup(db, input) {
+  const now = /* @__PURE__ */ new Date();
+  const record = {
+    ...input,
+    createdAt: now
+  };
+  db.insert(backups).values({
+    id: record.id,
+    operationId: record.operationId,
+    originalPath: record.originalPath,
+    backupPath: record.backupPath,
+    fileSize: record.fileSize,
+    fileHash: record.fileHash,
+    createdAt: record.createdAt,
+    expiresAt: record.expiresAt
+  }).run();
+  return record;
+}
+function deleteExpiredBackups(db) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.delete(backups).where(lt(backups.expiresAt, now)).run();
+  return result.changes;
+}
+
+// src/adapters/sqlite/trash.ts
+import { eq as eq6, and as and5, desc as desc2, lt as lt2 } from "drizzle-orm";
+function toTrashRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.sessionId,
+    appId: row.appId,
+    userId: row.userId,
+    originalPath: row.originalPath,
+    trashPath: row.trashPath,
+    deletedAt: row.deletedAt,
+    autoDeleteAt: row.autoDeleteAt
+  };
+}
+function getTrashItems(db, ctx) {
+  const tenantCondition = buildTrashTenantCondition(ctx);
+  const rows = db.select().from(trash).where(tenantCondition).orderBy(desc2(trash.deletedAt)).all();
+  return rows.map(toTrashRecord);
+}
+function moveToTrash(db, input, ctx, config) {
+  const now = /* @__PURE__ */ new Date();
+  const retentionDays = config.trashRetentionDays || 30;
+  const autoDeleteAt = new Date(now.getTime() + retentionDays * 24 * 60 * 60 * 1e3);
+  const record = {
+    ...input,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    deletedAt: now,
+    autoDeleteAt
+  };
+  db.insert(trash).values({
+    id: record.id,
+    sessionId: record.sessionId,
+    appId: record.appId,
+    userId: record.userId,
+    originalPath: record.originalPath,
+    trashPath: record.trashPath,
+    deletedAt: record.deletedAt,
+    autoDeleteAt: record.autoDeleteAt
+  }).run();
+  return record;
+}
+function restoreFromTrash(db, id, ctx) {
+  const tenantCondition = buildTrashTenantCondition(ctx);
+  const condition = tenantCondition ? and5(eq6(trash.id, id), tenantCondition) : eq6(trash.id, id);
+  const row = db.select().from(trash).where(condition).get();
+  if (!row) {
+    throw new Error("\u56DE\u6536\u7AD9\u8BB0\u5F55\u4E0D\u5B58\u5728");
+  }
+  db.delete(trash).where(eq6(trash.id, id)).run();
+  return toTrashRecord(row);
+}
+function emptyExpiredTrash(db) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.delete(trash).where(lt2(trash.autoDeleteAt, now)).run();
+  return result.changes;
+}
+
+// src/adapters/sqlite/embeddings.ts
+import { eq as eq7, and as and6 } from "drizzle-orm";
+function saveEmbedding(db, id, content, embedding, metadata, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  db.insert(embeddings).values({
+    id,
+    sessionId: metadata.sessionId,
+    messageId: metadata.messageId || null,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    content,
+    contentType: metadata.contentType,
+    embedding: JSON.stringify(embedding),
+    metadata: JSON.stringify(metadata),
+    createdAt: now
+  }).run();
+}
+function searchSimilar(db, queryEmbedding, options, ctx) {
+  const { limit = 10, threshold = 0.7, sessionId } = options;
+  const conditions = [];
+  if (ctx.appId) conditions.push(eq7(embeddings.appId, ctx.appId));
+  if (ctx.userId) conditions.push(eq7(embeddings.userId, ctx.userId));
+  if (sessionId) conditions.push(eq7(embeddings.sessionId, sessionId));
+  const rows = db.select().from(embeddings).where(conditions.length > 0 ? and6(...conditions) : void 0).all();
+  const results = rows.map((row) => {
+    const storedEmbedding = row.embedding ? JSON.parse(row.embedding) : [];
+    const similarity = cosineSimilarity(queryEmbedding, storedEmbedding);
+    return {
+      id: row.id,
+      content: row.content,
+      contentType: row.contentType,
+      similarity,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  return results;
+}
+function deleteSessionEmbeddings(db, sessionId) {
+  db.delete(embeddings).where(eq7(embeddings.sessionId, sessionId)).run();
+}
+
+// src/adapters/sqlite/index.ts
+var SqliteAdapter = class {
+  sqlite;
+  db;
+  config;
+  constructor(dbPath, config = { type: "sqlite" }) {
+    this.sqlite = new Database(dbPath);
+    this.db = drizzle(this.sqlite);
+    this.config = config;
+    initSchema(this.sqlite);
+  }
+  // ============ 会话 ============
+  async getSessions(ctx) {
+    return getSessions(this.db, ctx);
+  }
+  async getSession(id, ctx) {
+    return getSession(this.db, id, ctx);
+  }
+  async createSession(input, ctx) {
+    return createSession(this.db, input, ctx);
+  }
+  async updateSession(id, data, ctx) {
+    updateSession(this.db, id, data, ctx);
+  }
+  async deleteSession(id, ctx) {
+    deleteSessionMessages(this.db, id);
+    deleteSessionOperations(this.db, id);
+    deleteSessionEmbeddings(this.db, id);
+    deleteSession(this.db, id, ctx);
+  }
+  // ============ 消息 ============
+  async getMessages(sessionId, ctx) {
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return [];
+    return getMessages(this.db, sessionId);
+  }
+  async getMessage(id, ctx) {
+    return getMessage(this.db, id, ctx);
+  }
+  async saveMessage(input, ctx) {
+    return saveMessage(this.db, input, ctx);
+  }
+  async deleteMessagesAfter(sessionId, timestamp, ctx) {
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return;
+    deleteMessagesAfter(this.db, sessionId, timestamp);
+  }
+  // ============ 操作日志 ============
+  async getOperations(sessionId, ctx) {
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return [];
+    return getOperations(this.db, sessionId);
+  }
+  async getOperationsByMessage(messageId, ctx) {
+    return getOperationsByMessage(this.db, messageId, ctx);
+  }
+  async saveOperation(input, ctx) {
+    return saveOperation(this.db, input, ctx);
+  }
+  async updateOperationStatus(id, status, errorMessage) {
+    updateOperationStatus(this.db, id, status, errorMessage);
+  }
+  // ============ 备份 ============
+  async getBackups(operationId) {
+    return getBackups(this.db, operationId);
+  }
+  async saveBackup(input) {
+    return saveBackup(this.db, input);
+  }
+  async deleteExpiredBackups() {
+    return deleteExpiredBackups(this.db);
+  }
+  // ============ 回收站 ============
+  async getTrashItems(ctx) {
+    return getTrashItems(this.db, ctx);
+  }
+  async moveToTrash(input, ctx) {
+    return moveToTrash(this.db, input, ctx, this.config);
+  }
+  async restoreFromTrash(id, ctx) {
+    return restoreFromTrash(this.db, id, ctx);
+  }
+  async emptyExpiredTrash() {
+    return emptyExpiredTrash(this.db);
+  }
+  // ============ 向量搜索 ============
+  async saveEmbedding(id, content, embedding, metadata, ctx) {
+    saveEmbedding(this.db, id, content, embedding, metadata, ctx);
+  }
+  async searchSimilar(queryEmbedding, options, ctx) {
+    return searchSimilar(this.db, queryEmbedding, options, ctx);
+  }
+  // ============ 生命周期 ============
+  async close() {
+    this.sqlite.close();
+  }
+};
+
+export {
+  sessions,
+  messages,
+  operations,
+  backups,
+  trash,
+  embeddings,
+  SqliteAdapter
+};