@ykurilov/agent-chat-storage-sqlite 0.0.0-stage → 0.56.0

package/dist/index.js

@@ -0,0 +1,817 @@
+// src/sqlite-storage.ts
+import { fileURLToPath } from "url";
+import {
+  aliveAtByLocalClock,
+  assertChatDataFilter,
+  assertKnownFormatVersion,
+  ChatAlreadyExistsError,
+  chatDataFields,
+  chatDataOfInput,
+  DuplicateChatSubjectError,
+  DuplicateMessageError,
+  isOptimizationBlocked,
+  mergeChatData,
+  MessageAlreadyFinishedError,
+  MessageNotAwaitingError,
+  revertRefusal,
+  sameMessageParts,
+  silenceBoundaryByLocalClock
+} from "@ykurilov/agent-chat-core";
+import Database from "better-sqlite3";
+import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, sql as sql2 } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+
+// src/schema.ts
+import { sql } from "drizzle-orm";
+import { index, integer, real, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var chats = sqliteTable(
+  "chats",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    modelId: text("model_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    reasoning: text("reasoning"),
+    /** Название для списка чатов; пусто — чат без названия. */
+    title: text("title"),
+    /** Мессенджер, из которого создан чат; пусто — чат создан в вебе. */
+    origin: text("origin", { enum: ["telegram", "vk", "max"] }),
+    /** Ключ объекта приложения; пусто — обычный чат. У владельца ключ не повторяется. */
+    subjectKey: text("subject_key"),
+    /** Данные объекта (JSON-объект); пусто — данных нет. */
+    subjectData: text("subject_data", { mode: "json" }).$type(),
+    /** Закрытие чата (JSON `{ code, message }`); пусто — чат открыт. */
+    closed: text("closed", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (table) => [
+    index("chats_owner_updated_idx").on(table.ownerId, table.updatedAt),
+    uniqueIndex("chats_owner_subject_idx").on(table.ownerId, table.subjectKey)
+  ]
+);
+var messages = sqliteTable(
+  "messages",
+  {
+    id: text("id").primaryKey(),
+    chatId: text("chat_id").notNull().references(() => chats.id, { onDelete: "cascade" }),
+    parentId: text("parent_id"),
+    role: text("role", { enum: ["user", "assistant"] }).notNull(),
+    parts: text("parts", { mode: "json" }).$type().notNull(),
+    formatVersion: integer("format_version").notNull(),
+    status: text("status").$type().notNull(),
+    modelId: text("model_id"),
+    providerId: text("provider_id"),
+    usage: text("usage", { mode: "json" }).$type(),
+    reasoningDurationsMs: text("reasoning_durations_ms", { mode: "json" }).$type().notNull(),
+    error: text("error", { mode: "json" }).$type(),
+    /** Отметка обрыва озвучки (голосовой режим); пусто — озвучку не обрывали. */
+    voiceCut: text("voice_cut", { mode: "json" }).$type(),
+    /** Состояние хука итога хода; пусто — хук не зовётся. */
+    afterTurn: text("after_turn", { enum: ["pending", "done", "failed"] }),
+    createdAt: text("created_at").notNull(),
+    /** Последний знак жизни идущего ответа (ISO); пусто — время создания. Только для восстановления, при чтении не отдаётся. */
+    aliveAt: text("alive_at"),
+    /** Порядок записи: при равном `created_at` сообщения читаются по возрастанию `seq`. Задаётся при вставке. */
+    seq: integer("seq").notNull().default(0)
+  },
+  (table) => [
+    index("messages_chat_created_idx").on(table.chatId, table.createdAt, table.seq),
+    uniqueIndex("messages_seq_idx").on(table.seq),
+    index("messages_streaming_idx").on(table.status).where(sql`${table.status} = 'streaming'`),
+    index("messages_after_turn_pending_idx").on(table.afterTurn).where(sql`${table.afterTurn} = 'pending'`)
+  ]
+);
+var compactions = sqliteTable(
+  "compactions",
+  {
+    id: text("id").primaryKey(),
+    chatId: text("chat_id").notNull().references(() => chats.id, { onDelete: "cascade" }),
+    fromMessageId: text("from_message_id").notNull(),
+    throughMessageId: text("through_message_id").notNull(),
+    summary: text("summary").notNull(),
+    summaryTokens: integer("summary_tokens").notNull(),
+    modelId: text("model_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    usage: text("usage", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    seq: integer("seq").notNull().default(0)
+  },
+  (table) => [
+    index("compactions_chat_seq_idx").on(table.chatId, table.seq),
+    uniqueIndex("compactions_seq_idx").on(table.seq)
+  ]
+);
+var branchSelections = sqliteTable(
+  "branch_selections",
+  {
+    id: text("id").primaryKey(),
+    chatId: text("chat_id").notNull().references(() => chats.id, { onDelete: "cascade" }),
+    messageId: text("message_id").notNull(),
+    selectedAt: text("selected_at").notNull(),
+    seq: integer("seq").notNull().default(0)
+  },
+  (table) => [
+    index("branch_selections_chat_seq_idx").on(table.chatId, table.seq),
+    uniqueIndex("branch_selections_seq_idx").on(table.seq)
+  ]
+);
+var usageRecords = sqliteTable(
+  "usage_records",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    chatId: text("chat_id").notNull(),
+    messageId: text("message_id"),
+    source: text("source").$type().notNull(),
+    modelId: text("model_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    inputTokens: integer("input_tokens").notNull(),
+    cachedInputTokens: integer("cached_input_tokens").notNull(),
+    cacheWriteTokens: integer("cache_write_tokens").notNull(),
+    outputTokens: integer("output_tokens").notNull(),
+    reasoningTokens: integer("reasoning_tokens").notNull(),
+    costUsd: real("cost_usd").notNull(),
+    createdAt: text("created_at").notNull(),
+    /** Числа «примерно»: прикинуты по длине текста, а не сообщены провайдером. */
+    estimated: integer("estimated", { mode: "boolean" }).notNull().default(false)
+  },
+  (table) => [
+    index("usage_records_owner_created_idx").on(table.ownerId, table.createdAt),
+    index("usage_records_chat_created_idx").on(table.chatId, table.createdAt)
+  ]
+);
+var userModelChoices = sqliteTable("user_model_choices", {
+  ownerId: text("owner_id").primaryKey(),
+  modelId: text("model_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  /** Пусто — у модели нет уровней рассуждений. */
+  reasoning: text("reasoning"),
+  updatedAt: text("updated_at").notNull()
+});
+var voiceChoices = sqliteTable("voice_choices", {
+  ownerId: text("owner_id").primaryKey(),
+  voiceId: text("voice_id").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var spendingLimitStates = sqliteTable("spending_limit_states", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  version: integer("version").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var chatTurnLeases = sqliteTable("chat_turn_leases", {
+  chatId: text("chat_id").primaryKey(),
+  holder: text("holder").notNull(),
+  until: integer("until").notNull()
+});
+var memoryNotes = sqliteTable(
+  "memory_notes",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    categories: text("categories", { mode: "json" }).$type().notNull(),
+    content: text("content").notNull(),
+    version: integer("version").notNull().default(1),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    /** Оптимизация дублей: id записи-результата у скрытого оригинала слияния; у обычных записей пусто. */
+    mergedInto: text("merged_into")
+  },
+  (table) => [
+    index("memory_notes_owner_updated_idx").on(table.ownerId, table.updatedAt),
+    index("memory_notes_merged_into_idx").on(table.mergedInto)
+  ]
+);
+var memoryOptimizationRuns = sqliteTable(
+  "memory_optimization_runs",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    startedAt: integer("started_at").notNull(),
+    finishedAt: integer("finished_at"),
+    status: text("status").$type().notNull(),
+    groups: text("groups", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+    error: text("error"),
+    usageRecordId: text("usage_record_id")
+  },
+  (table) => [
+    index("memory_optimization_runs_owner_started_idx").on(table.ownerId, table.startedAt),
+    uniqueIndex("memory_optimization_runs_one_running_idx").on(table.ownerId).where(sql`${table.status} = 'running'`)
+  ]
+);
+
+// src/sqlite-storage.ts
+var migrationsFolder = fileURLToPath(new URL("../drizzle", import.meta.url));
+var MIGRATIONS_TABLE = "__agent_chat_migrations";
+var SHARED_MIGRATIONS_TABLE = "__drizzle_migrations";
+var ForeignChatTablesError = class extends Error {
+  constructor(filePath, tables) {
+    super(
+      `\u0412 \u0444\u0430\u0439\u043B\u0435 ${filePath} \u0447\u0443\u0436\u0438\u0435 \u0442\u0430\u0431\u043B\u0438\u0446\u044B ${tables.join(" \u0438 ")}: \u0438\u0445 \u0441\u043E\u0437\u0434\u0430\u043B\u043E \u043D\u0435 SDK \u0447\u0430\u0442\u0430. \u0414\u0430\u0439\u0442\u0435 SDK \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u044B\u0439 \u0444\u0430\u0439\u043B (\u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440, data/chat.sqlite): \u043E\u0431\u0449\u0438\u0439 \u0444\u0430\u0439\u043B \u0441 \u0442\u0430\u0431\u043B\u0438\u0446\u0430\u043C\u0438 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F. \u0424\u0430\u0439\u043B \u043D\u0435 \u0442\u0440\u043E\u043D\u0443\u0442.`
+    );
+    this.filePath = filePath;
+    this.tables = tables;
+    this.name = "ForeignChatTablesError";
+  }
+  filePath;
+  tables;
+};
+function assertNoForeignChatTables(sqlite, filePath) {
+  const names = tableNames(sqlite);
+  const found = ["chats", "messages"].filter((name) => names.has(name));
+  if (found.length === 0) return;
+  const firstMigrationHash = readMigrationFiles({ migrationsFolder })[0]?.hash;
+  const ours = [MIGRATIONS_TABLE, SHARED_MIGRATIONS_TABLE].some((table) => {
+    try {
+      return names.has(table) && sqlite.prepare(`select 1 from "${table}" where hash = ?`).get(firstMigrationHash) !== void 0;
+    } catch {
+      return false;
+    }
+  });
+  if (!ours) throw new ForeignChatTablesError(filePath, found);
+}
+function tableNames(sqlite) {
+  return new Set(sqlite.prepare("select name from sqlite_master where type = 'table'").pluck().all());
+}
+function moveSharedMigrationJournal(sqlite) {
+  sqlite.transaction(() => {
+    const names = tableNames(sqlite);
+    if (names.has(MIGRATIONS_TABLE) || !names.has(SHARED_MIGRATIONS_TABLE)) return;
+    let rows;
+    try {
+      rows = sqlite.prepare(`select hash, created_at from "${SHARED_MIGRATIONS_TABLE}"`).all();
+    } catch {
+      return;
+    }
+    const sdk = readMigrationFiles({ migrationsFolder });
+    const ours = rows.filter((row) => sdk.some((migration) => migration.hash === row.hash || migration.folderMillis === Number(row.created_at)));
+    if (ours.length === 0) return;
+    sqlite.exec(`create table "${MIGRATIONS_TABLE}" (id SERIAL PRIMARY KEY, hash text NOT NULL, created_at numeric)`);
+    const insert = sqlite.prepare(`insert into "${MIGRATIONS_TABLE}" (hash, created_at) values (?, ?)`);
+    for (const row of ours) insert.run(row.hash, row.created_at);
+  }).immediate();
+}
+function applyMigrations(sqlite) {
+  const migrations = readMigrationFiles({ migrationsFolder });
+  sqlite.transaction(() => {
+    sqlite.exec(`create table if not exists "${MIGRATIONS_TABLE}" (id SERIAL PRIMARY KEY, hash text NOT NULL, created_at numeric)`);
+    const rows = sqlite.prepare(`select hash, created_at from "${MIGRATIONS_TABLE}"`).all();
+    const hashes = new Set(rows.map((row) => row.hash));
+    const times = new Set(rows.map((row) => Number(row.created_at)));
+    const record = sqlite.prepare(`insert into "${MIGRATIONS_TABLE}" (hash, created_at) values (?, ?)`);
+    for (const migration of migrations) {
+      if (hashes.has(migration.hash) || times.has(migration.folderMillis)) continue;
+      for (const statement of migration.sql) if (statement.trim()) sqlite.exec(statement);
+      record.run(migration.hash, migration.folderMillis);
+    }
+  }).immediate();
+}
+function createSqliteChatStorage(options) {
+  const sqlite = new Database(options.filePath);
+  try {
+    assertNoForeignChatTables(sqlite, options.filePath);
+    moveSharedMigrationJournal(sqlite);
+  } catch (error) {
+    sqlite.close();
+    throw error;
+  }
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  const db = drizzle(sqlite, { schema: { chats, messages, compactions, branchSelections, usageRecords, userModelChoices, voiceChoices, spendingLimitStates, memoryNotes, memoryOptimizationRuns } });
+  applyMigrations(sqlite);
+  function visibleNotes(tx, ownerId) {
+    return tx.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), isNull(memoryNotes.mergedInto))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), desc(memoryNotes.id)).all().map(toMemoryNote);
+  }
+  function insertNotes(tx, ownerId, inputs) {
+    const now = Date.now();
+    const rows = inputs.map(({ categories, content }) => ({
+      id: crypto.randomUUID(),
+      ownerId,
+      categories,
+      content,
+      version: 1,
+      createdAt: now,
+      updatedAt: now
+    }));
+    for (const row of rows) tx.insert(memoryNotes).values(row).run();
+    return rows.map((row) => toMemoryNote(row));
+  }
+  function updateNote(tx, ownerId, id, expectedVersion, input) {
+    const row = tx.select().from(memoryNotes).where(ownerNote(ownerId, id)).get();
+    if (!row) return "not_found";
+    if (row.version !== expectedVersion) return "stale_version";
+    const updated = tx.update(memoryNotes).set({
+      categories: input.categories,
+      content: input.content,
+      version: row.version + 1,
+      // Часы не отстают от записи: время правки не убывает.
+      updatedAt: Math.max(Date.now(), row.updatedAt)
+    }).where(and(ownerNote(ownerId, id), eq(memoryNotes.version, expectedVersion))).returning().get();
+    return updated ? toMemoryNote(updated) : "stale_version";
+  }
+  const aliveAtColumn = (alive) => alive ? { aliveAt: aliveAtByLocalClock(alive) } : {};
+  function updateStreaming(messageId, { alive, ...values }) {
+    const result = db.update(messages).set({ ...values, ...aliveAtColumn(alive) }).where(and(eq(messages.id, messageId), eq(messages.status, "streaming"))).run();
+    if (result.changes > 0) return;
+    const existing = db.select({ id: messages.id }).from(messages).where(eq(messages.id, messageId)).get();
+    if (!existing) throw new Error(`\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F ${messageId} \u043D\u0435\u0442`);
+    throw new MessageAlreadyFinishedError(messageId);
+  }
+  return {
+    async createChat({ createdAt, ...input }) {
+      const at = createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      const row = chatRow({ ...input, createdAt: at, updatedAt: at });
+      try {
+        db.insert(chats).values(row).run();
+      } catch (error) {
+        if (isSubjectConflict(error)) throw new DuplicateChatSubjectError(input.ownerId, input.subjectKey);
+        throw error;
+      }
+      return toChat(row);
+    },
+    async findChatBySubject(ownerId, subjectKey) {
+      const row = db.select().from(chats).where(and(eq(chats.ownerId, ownerId), eq(chats.subjectKey, subjectKey))).get();
+      return row ? toChat(row) : null;
+    },
+    async importChat(chat, imported) {
+      db.transaction((tx) => {
+        try {
+          tx.insert(chats).values(chatRow(chat)).run();
+        } catch (error) {
+          if (isSubjectConflict(error)) throw new DuplicateChatSubjectError(chat.ownerId, chat.subjectKey);
+          if (isPrimaryKeyConflict(error)) throw new ChatAlreadyExistsError(chat.id);
+          throw error;
+        }
+        for (const message of imported) {
+          const nextSeq = sql2`(select coalesce(max(${messages.seq}), 0) + 1 from ${messages})`;
+          const { alive: _alive, ...stored } = message;
+          try {
+            tx.insert(messages).values({ ...stored, seq: nextSeq }).run();
+          } catch (error) {
+            if (isPrimaryKeyConflict(error)) throw new DuplicateMessageError(message.id);
+            throw error;
+          }
+        }
+      }, { behavior: "immediate" });
+    },
+    async setAfterTurnState(messageId, state, options2) {
+      return db.transaction(
+        (tx) => {
+          const existing = tx.select({ parts: messages.parts, afterTurn: messages.afterTurn }).from(messages).where(eq(messages.id, messageId)).get();
+          if (!existing || state !== "pending" && existing.afterTurn !== "pending") return false;
+          tx.update(messages).set({
+            afterTurn: state,
+            ...options2?.appendParts && { parts: [...existing.parts, ...options2.appendParts] },
+            // Отметка ожидания хука — в колонке знака жизни: у законченного ответа она больше ни для чего.
+            ...state === "pending" && aliveAtColumn("now")
+          }).where(eq(messages.id, messageId)).run();
+          return true;
+        },
+        { behavior: "immediate" }
+      );
+    },
+    async listPendingAfterTurn(filter) {
+      return db.select({ id: messages.id }).from(messages).where(
+        filter?.pendingForMs === void 0 ? eq(messages.afterTurn, "pending") : and(
+          eq(messages.afterTurn, "pending"),
+          sql2`coalesce(${messages.aliveAt}, ${messages.createdAt}) < ${silenceBoundaryByLocalClock(filter.pendingForMs)}`
+        )
+      ).all().map((row) => row.id);
+    },
+    async getChat(chatId) {
+      const row = db.select().from(chats).where(eq(chats.id, chatId)).get();
+      return row ? toChat(row) : null;
+    },
+    async updateChatModel(chatId, model) {
+      db.update(chats).set({ modelId: model.modelId, providerId: model.providerId, reasoning: model.reasoning ?? null }).where(eq(chats.id, chatId)).run();
+    },
+    async updateChatData(chatId, patch, { maxBytes }) {
+      return db.transaction(
+        (tx) => {
+          const row = tx.select().from(chats).where(eq(chats.id, chatId)).get();
+          if (!row) return null;
+          const merged = mergeChatData(row.subjectData ?? void 0, patch, maxBytes);
+          tx.update(chats).set({ subjectData: merged ?? null }).where(eq(chats.id, chatId)).run();
+          return toChat({ ...row, subjectData: merged ?? null });
+        },
+        { behavior: "immediate" }
+      );
+    },
+    async listChats(ownerId, options2) {
+      if (options2?.data) assertChatDataFilter(options2.data);
+      const rows = db.select().from(chats).where(and(eq(chats.ownerId, ownerId), subjectCondition(options2?.subjects), ...dataConditions(options2?.data))).orderBy(desc(chats.updatedAt), desc(chats.createdAt), desc(chats.id)).all();
+      return rows.map(toChat);
+    },
+    async renameChat(chatId, title) {
+      db.update(chats).set({ title }).where(eq(chats.id, chatId)).run();
+    },
+    async setChatClosed(chatId, closed) {
+      db.update(chats).set({ closed: closed && { code: closed.code, message: closed.message } }).where(eq(chats.id, chatId)).run();
+    },
+    async deleteChat(chatId) {
+      db.transaction((tx) => {
+        tx.delete(compactions).where(eq(compactions.chatId, chatId)).run();
+        tx.delete(branchSelections).where(eq(branchSelections.chatId, chatId)).run();
+        tx.delete(messages).where(eq(messages.chatId, chatId)).run();
+        tx.delete(chats).where(eq(chats.id, chatId)).run();
+        tx.delete(chatTurnLeases).where(eq(chatTurnLeases.chatId, chatId)).run();
+      }, { behavior: "immediate" });
+    },
+    async claimChatTurn(chatId, holder, leaseMs) {
+      const now = Date.now();
+      const claimed = db.insert(chatTurnLeases).values({ chatId, holder, until: now + leaseMs }).onConflictDoUpdate({
+        target: chatTurnLeases.chatId,
+        set: { holder, until: now + leaseMs },
+        setWhere: sql2`${chatTurnLeases.holder} = ${holder} or ${chatTurnLeases.until} <= ${now}`
+      }).returning({ chatId: chatTurnLeases.chatId }).all();
+      return claimed.length > 0;
+    },
+    async releaseChatTurn(chatId, holder) {
+      db.delete(chatTurnLeases).where(and(eq(chatTurnLeases.chatId, chatId), eq(chatTurnLeases.holder, holder))).run();
+    },
+    async clearChatTurnLeases() {
+      db.delete(chatTurnLeases).run();
+    },
+    async getMessage(messageId) {
+      const row = db.select().from(messages).where(eq(messages.id, messageId)).get();
+      if (!row) return null;
+      const message = toMessage(row);
+      assertKnownFormatVersion(message);
+      return message;
+    },
+    // При равном времени порядок записи задаёт `seq`: `rowid` VACUUM вправе перенумеровать.
+    async listMessages(chatId) {
+      const rows = db.select().from(messages).where(eq(messages.chatId, chatId)).orderBy(asc(messages.createdAt), messages.seq).all();
+      const found = rows.map(toMessage);
+      found.forEach(assertKnownFormatVersion);
+      return found;
+    },
+    async listMessageLinks(chatId) {
+      return db.select({ id: messages.id, parentId: messages.parentId, createdAt: messages.createdAt }).from(messages).where(eq(messages.chatId, chatId)).orderBy(asc(messages.createdAt), messages.seq).all();
+    },
+    // Части нужных типов выбираются внутри базы: тексты и выводы инструментов в процесс не идут.
+    async listMessagePartsOfTypes(chatId, types) {
+      const wanted = JSON.stringify([...types]);
+      const rows = db.select({
+        id: messages.id,
+        parentId: messages.parentId,
+        createdAt: messages.createdAt,
+        parts: sql2`(select coalesce(json_group_array(json(picked.value)), '[]') from (select part.value from json_each(${messages.parts}) as part where json_extract(part.value, '$.type') in (select value from json_each(${wanted})) order by part.key) as picked)`
+      }).from(messages).where(eq(messages.chatId, chatId)).orderBy(asc(messages.createdAt), messages.seq).all();
+      return rows.map((row) => ({ ...row, parts: JSON.parse(row.parts) }));
+    },
+    async insertMessage(message) {
+      try {
+        db.transaction((tx) => {
+          const nextSeq = sql2`(select coalesce(max(${messages.seq}), 0) + 1 from ${messages})`;
+          const { alive, ...stored } = message;
+          tx.insert(messages).values({ ...stored, ...aliveAtColumn(alive), seq: nextSeq }).run();
+          tx.update(chats).set({ updatedAt: message.createdAt }).where(eq(chats.id, message.chatId)).run();
+        }, { behavior: "immediate" });
+      } catch (error) {
+        if (isPrimaryKeyConflict(error)) throw new DuplicateMessageError(message.id);
+        throw error;
+      }
+    },
+    updateStreamingMessage: async (messageId, patch) => updateStreaming(messageId, patch),
+    markAnswerAlive: async (messageId) => updateStreaming(messageId, { alive: "now" }),
+    finishMessage: async (messageId, final) => updateStreaming(messageId, { ...final, ...final.afterTurn === "pending" && { alive: "now" } }),
+    async updateAwaitingMessage(messageId, patch) {
+      db.transaction(
+        (tx) => {
+          const existing = tx.select({ status: messages.status, parts: messages.parts }).from(messages).where(eq(messages.id, messageId)).get();
+          if (!existing) throw new Error(`\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F ${messageId} \u043D\u0435\u0442`);
+          if (existing.status !== "awaiting_approval") throw new MessageNotAwaitingError(messageId);
+          if (patch.expectedParts && !sameMessageParts(existing.parts, patch.expectedParts)) throw new MessageNotAwaitingError(messageId);
+          tx.update(messages).set({ parts: patch.parts, ...patch.status && { status: patch.status }, ...aliveAtColumn(patch.alive) }).where(eq(messages.id, messageId)).run();
+        },
+        { behavior: "immediate" }
+      );
+    },
+    async listStreamingMessageIds() {
+      return db.select({ id: messages.id }).from(messages).where(eq(messages.status, "streaming")).all().map((row) => row.id);
+    },
+    async listSilentAnswerIds({ silentForMs, chatId }) {
+      const silent = sql2`coalesce(${messages.aliveAt}, ${messages.createdAt}) < ${silenceBoundaryByLocalClock(silentForMs)}`;
+      return db.select({ id: messages.id }).from(messages).where(and(eq(messages.status, "streaming"), silent, chatId === void 0 ? void 0 : eq(messages.chatId, chatId))).all().map((row) => row.id);
+    },
+    async insertCompaction(record) {
+      const nextSeq = sql2`(select coalesce(max(${compactions.seq}), 0) + 1 from ${compactions})`;
+      db.insert(compactions).values({ ...record, seq: nextSeq }).run();
+    },
+    async listCompactions(chatId) {
+      const rows = db.select().from(compactions).where(eq(compactions.chatId, chatId)).orderBy(asc(compactions.seq)).all();
+      return rows.map(({ seq: _seq, ...record }) => record);
+    },
+    async insertBranchSelection(record) {
+      const nextSeq = sql2`(select coalesce(max(${branchSelections.seq}), 0) + 1 from ${branchSelections})`;
+      db.insert(branchSelections).values({ ...record, seq: nextSeq }).run();
+    },
+    async listBranchSelections(chatId) {
+      const rows = db.select().from(branchSelections).where(eq(branchSelections.chatId, chatId)).orderBy(asc(branchSelections.seq)).all();
+      return rows.map(({ seq: _seq, ...record }) => record);
+    },
+    async insertUsageRecord(record) {
+      db.insert(usageRecords).values(record).run();
+    },
+    async hasUsageRecord(id) {
+      return db.select({ id: usageRecords.id }).from(usageRecords).where(eq(usageRecords.id, id)).get() !== void 0;
+    },
+    async sumUsage({ ownerId, chatId, messageId, source, since }) {
+      const filters = [
+        ...ownerId !== void 0 ? [eq(usageRecords.ownerId, ownerId)] : [],
+        ...chatId !== void 0 ? [eq(usageRecords.chatId, chatId)] : [],
+        ...messageId !== void 0 ? [eq(usageRecords.messageId, messageId)] : [],
+        ...source !== void 0 ? [eq(usageRecords.source, source)] : [],
+        ...since !== void 0 ? [gte(usageRecords.createdAt, since)] : []
+      ];
+      return db.select({
+        modelId: usageRecords.modelId,
+        providerId: usageRecords.providerId,
+        inputTokens: sql2`sum(${usageRecords.inputTokens})`.mapWith(Number),
+        cachedInputTokens: sql2`sum(${usageRecords.cachedInputTokens})`.mapWith(Number),
+        cacheWriteTokens: sql2`sum(${usageRecords.cacheWriteTokens})`.mapWith(Number),
+        outputTokens: sql2`sum(${usageRecords.outputTokens})`.mapWith(Number),
+        reasoningTokens: sql2`sum(${usageRecords.reasoningTokens})`.mapWith(Number),
+        costUsd: sql2`sum(${usageRecords.costUsd})`.mapWith(Number)
+      }).from(usageRecords).where(and(...filters)).groupBy(usageRecords.modelId, usageRecords.providerId).all();
+    },
+    async sumUsageByChat({ chatIds, ownerId, source, since }) {
+      if (chatIds.length === 0) return [];
+      const filters = [
+        inArray(usageRecords.chatId, [...chatIds]),
+        ...ownerId !== void 0 ? [eq(usageRecords.ownerId, ownerId)] : [],
+        ...source !== void 0 ? [eq(usageRecords.source, source)] : [],
+        ...since !== void 0 ? [gte(usageRecords.createdAt, since)] : []
+      ];
+      return db.select({
+        chatId: usageRecords.chatId,
+        modelId: usageRecords.modelId,
+        providerId: usageRecords.providerId,
+        inputTokens: sql2`sum(${usageRecords.inputTokens})`.mapWith(Number),
+        cachedInputTokens: sql2`sum(${usageRecords.cachedInputTokens})`.mapWith(Number),
+        cacheWriteTokens: sql2`sum(${usageRecords.cacheWriteTokens})`.mapWith(Number),
+        outputTokens: sql2`sum(${usageRecords.outputTokens})`.mapWith(Number),
+        reasoningTokens: sql2`sum(${usageRecords.reasoningTokens})`.mapWith(Number),
+        costUsd: sql2`sum(${usageRecords.costUsd})`.mapWith(Number)
+      }).from(usageRecords).where(and(...filters)).groupBy(usageRecords.chatId, usageRecords.modelId, usageRecords.providerId).all();
+    },
+    async getUserModelChoice(ownerId) {
+      const row = db.select().from(userModelChoices).where(eq(userModelChoices.ownerId, ownerId)).get();
+      if (!row) return null;
+      return { modelId: row.modelId, providerId: row.providerId, ...row.reasoning !== null && { reasoning: row.reasoning } };
+    },
+    async saveUserModelChoice(ownerId, choice) {
+      const values = { modelId: choice.modelId, providerId: choice.providerId, reasoning: choice.reasoning ?? null, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      db.insert(userModelChoices).values({ ownerId, ...values }).onConflictDoUpdate({ target: userModelChoices.ownerId, set: values }).run();
+    },
+    async setVoiceCut({ ownerId, chatId, messageId, voiceCut }) {
+      db.update(messages).set({ voiceCut }).where(
+        and(
+          eq(messages.id, messageId),
+          eq(messages.chatId, chatId),
+          sql2`exists (select 1 from ${chats} where ${chats.id} = ${chatId} and ${chats.ownerId} = ${ownerId})`
+        )
+      ).run();
+    },
+    async getSpendingLimitState(key) {
+      const row = db.select().from(spendingLimitStates).where(eq(spendingLimitStates.key, key)).get();
+      return row ? { value: row.value, version: row.version } : null;
+    },
+    // Одна команда без чтения: вставка или правка срабатывает только при совпавшей версии, лишнего «вклинивания» нет.
+    async saveSpendingLimitState(key, value, expectedVersion) {
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (expectedVersion === null) {
+        return db.insert(spendingLimitStates).values({ key, value, version: 1, updatedAt }).onConflictDoNothing().run().changes === 1;
+      }
+      const changed = db.update(spendingLimitStates).set({ value, version: expectedVersion + 1, updatedAt }).where(and(eq(spendingLimitStates.key, key), eq(spendingLimitStates.version, expectedVersion))).run().changes;
+      return changed === 1;
+    },
+    async deleteSpendingLimitStates(keys) {
+      if (keys.length > 0) db.delete(spendingLimitStates).where(inArray(spendingLimitStates.key, keys)).run();
+    },
+    async getVoiceChoice(ownerId) {
+      return db.select().from(voiceChoices).where(eq(voiceChoices.ownerId, ownerId)).get()?.voiceId ?? null;
+    },
+    async setVoiceChoice(ownerId, voiceId) {
+      const values = { voiceId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      db.insert(voiceChoices).values({ ownerId, ...values }).onConflictDoUpdate({ target: voiceChoices.ownerId, set: values }).run();
+    },
+    async listMemoryNotes(ownerId) {
+      return db.transaction((tx) => visibleNotes(tx, ownerId));
+    },
+    // Пакет вставляется одной транзакцией: негодная запись (NOT NULL) откатывает и остальные.
+    async insertMemoryNotes(ownerId, inputs) {
+      return db.transaction((tx) => insertNotes(tx, ownerId, inputs), { behavior: "immediate" });
+    },
+    async insertMemoryNotesChecked(ownerId, inputs, guard) {
+      return db.transaction(
+        (tx) => {
+          const error = guard(visibleNotes(tx, ownerId));
+          return error ?? insertNotes(tx, ownerId, inputs);
+        },
+        { behavior: "immediate" }
+      );
+    },
+    async updateMemoryNote(ownerId, id, expectedVersion, input) {
+      return db.transaction((tx) => updateNote(tx, ownerId, id, expectedVersion, input), { behavior: "immediate" });
+    },
+    async updateMemoryNoteChecked(ownerId, id, expectedVersion, input, guard) {
+      return db.transaction((tx) => guard(visibleNotes(tx, ownerId)) ?? updateNote(tx, ownerId, id, expectedVersion, input), { behavior: "immediate" });
+    },
+    async deleteMemoryNote(ownerId, id, expectedVersion) {
+      return db.transaction((tx) => {
+        const row = tx.select({ version: memoryNotes.version }).from(memoryNotes).where(ownerNote(ownerId, id)).get();
+        if (!row) return "not_found";
+        if (row.version !== expectedVersion) return "stale_version";
+        const result = tx.delete(memoryNotes).where(and(ownerNote(ownerId, id), eq(memoryNotes.version, expectedVersion))).run();
+        if (result.changes === 0) return "stale_version";
+        tx.delete(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, id))).run();
+        return "ok";
+      }, { behavior: "immediate" });
+    },
+    async clearMemoryNotes(ownerId) {
+      return db.transaction((tx) => {
+        const deleted = tx.delete(memoryNotes).where(eq(memoryNotes.ownerId, ownerId)).returning({ mergedInto: memoryNotes.mergedInto }).all();
+        tx.delete(memoryOptimizationRuns).where(eq(memoryOptimizationRuns.ownerId, ownerId)).run();
+        return deleted.filter((row) => row.mergedInto === null).length;
+      }, { behavior: "immediate" });
+    },
+    // Взятие запуска — одна транзакция: проверка правил и вставка не разрываются (SQLite пишет по одному).
+    async claimMemoryOptimizationRun(ownerId, rules, now) {
+      const nowMs = Date.parse(now);
+      return db.transaction((tx) => {
+        const runs = tx.select().from(memoryOptimizationRuns).where(eq(memoryOptimizationRuns.ownerId, ownerId)).all();
+        for (const run of runs) {
+          const leaseEnd = run.startedAt + rules.leaseMs;
+          if (run.status !== "running" || nowMs < leaseEnd) continue;
+          tx.update(memoryOptimizationRuns).set({ status: "failed", error: "lease_expired", finishedAt: leaseEnd }).where(eq(memoryOptimizationRuns.id, run.id)).run();
+          Object.assign(run, { status: "failed", finishedAt: leaseEnd });
+        }
+        const blocked = isOptimizationBlocked(
+          runs.map((run) => ({ status: run.status, startedAtMs: run.startedAt, endedAtMs: run.finishedAt })),
+          rules,
+          nowMs
+        );
+        if (blocked) return null;
+        const row = { id: crypto.randomUUID(), ownerId, startedAt: nowMs, finishedAt: null, status: "running", groups: [], error: null, usageRecordId: null };
+        tx.insert(memoryOptimizationRuns).values(row).run();
+        return toOptimizationRun(row);
+      }, { behavior: "immediate" });
+    },
+    async finishMemoryOptimizationRun(ownerId, runId, outcome) {
+      const result = db.update(memoryOptimizationRuns).set({ status: outcome.status, finishedAt: Date.parse(outcome.finishedAt), error: outcome.error ?? null, usageRecordId: outcome.usageRecordId ?? null }).where(and(eq(memoryOptimizationRuns.id, runId), eq(memoryOptimizationRuns.ownerId, ownerId), eq(memoryOptimizationRuns.status, "running"))).run();
+      return result.changes > 0 ? "ok" : "not_found";
+    },
+    // Слияние — одна транзакция: любая неудача (в том числе негодный результат) откатывает всё.
+    async applyMemoryMerge(ownerId, merge) {
+      const { merges } = merge;
+      if (merges.length === 0) throw new TypeError("\u0421\u043B\u0438\u044F\u043D\u0438\u0435 \u0431\u0435\u0437 \u0441\u043A\u043B\u0435\u0435\u043A");
+      const seen = /* @__PURE__ */ new Set();
+      for (const { originals } of merges) {
+        if (originals.length === 0) throw new TypeError("\u0421\u043A\u043B\u0435\u0439\u043A\u0430 \u0431\u0435\u0437 \u043E\u0440\u0438\u0433\u0438\u043D\u0430\u043B\u043E\u0432");
+        for (const { id } of originals) {
+          if (seen.has(id)) throw new TypeError(`\u0417\u0430\u043F\u0438\u0441\u044C ${id} \u043D\u0430\u0437\u0432\u0430\u043D\u0430 \u0432 \u0434\u0432\u0443\u0445 \u0441\u043A\u043B\u0435\u0439\u043A\u0430\u0445`);
+          seen.add(id);
+        }
+      }
+      return db.transaction((tx) => {
+        const run = tx.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.id, merge.runId), eq(memoryOptimizationRuns.ownerId, ownerId))).get();
+        if (run?.status !== "running") return "run_not_active";
+        for (const { originals } of merges) {
+          for (const { id, version } of originals) {
+            const original = tx.select({ version: memoryNotes.version }).from(memoryNotes).where(ownerNote(ownerId, id)).get();
+            if (original?.version !== version) return "stale_version";
+          }
+        }
+        const now = Date.now();
+        const groups = merges.map(({ result, originals }) => {
+          const created = { id: crypto.randomUUID(), ownerId, categories: result.categories, content: result.content, version: 1, createdAt: now, updatedAt: now };
+          tx.insert(memoryNotes).values(created).run();
+          for (const { id } of originals) tx.update(memoryNotes).set({ mergedInto: created.id }).where(ownerNote(ownerId, id)).run();
+          return { resultId: created.id, originalIds: originals.map(({ id }) => id), resultVersion: 1 };
+        });
+        const finished = { status: "applied", finishedAt: Date.parse(merge.finishedAt), groups, usageRecordId: merge.usageRecordId ?? null };
+        tx.update(memoryOptimizationRuns).set(finished).where(eq(memoryOptimizationRuns.id, run.id)).run();
+        return toOptimizationRun({ ...run, ...finished });
+      }, { behavior: "immediate" });
+    },
+    async revertMemoryMerge(ownerId, runId, guard) {
+      return db.transaction((tx) => {
+        const run = tx.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.id, runId), eq(memoryOptimizationRuns.ownerId, ownerId))).get();
+        if (run?.status !== "applied") return "not_found";
+        for (const { resultId, originalIds, resultVersion } of run.groups) {
+          const result = tx.select({ version: memoryNotes.version }).from(memoryNotes).where(ownerNote(ownerId, resultId)).get();
+          if (result?.version !== resultVersion) return "conflict";
+          const hidden = tx.select({ id: memoryNotes.id }).from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, resultId), inArray(memoryNotes.id, originalIds))).all();
+          if (hidden.length !== originalIds.length) return "conflict";
+        }
+        if (guard) {
+          const resultIds = run.groups.map(({ resultId }) => resultId);
+          const remaining = visibleNotes(tx, ownerId).filter((note) => !resultIds.includes(note.id));
+          const restored = tx.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), inArray(memoryNotes.mergedInto, resultIds))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), desc(memoryNotes.id)).all().map(toMemoryNote);
+          const error = guard(remaining, restored);
+          if (error) return revertRefusal(error);
+        }
+        for (const { resultId } of run.groups) {
+          tx.update(memoryNotes).set({ mergedInto: null }).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, resultId))).run();
+          tx.delete(memoryNotes).where(ownerNote(ownerId, resultId)).run();
+        }
+        tx.update(memoryOptimizationRuns).set({ status: "reverted" }).where(eq(memoryOptimizationRuns.id, run.id)).run();
+        return "ok";
+      }, { behavior: "immediate" });
+    },
+    async listMemoryOptimizationRuns(ownerId, filter) {
+      const rows = db.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.ownerId, ownerId), ...filter?.status ? [inArray(memoryOptimizationRuns.status, filter.status)] : [])).orderBy(desc(memoryOptimizationRuns.startedAt), sql2`rowid desc`).limit(filter?.limit ?? -1).all();
+      return rows.map(toOptimizationRun);
+    },
+    async listMergedMemoryNotes(ownerId) {
+      const rows = db.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), isNotNull(memoryNotes.mergedInto))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), desc(memoryNotes.id)).all();
+      return rows.map((row) => ({ ...toMemoryNote(row), mergedInto: row.mergedInto }));
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}
+function chatRow(chat) {
+  return {
+    id: chat.id,
+    ownerId: chat.ownerId,
+    modelId: chat.modelId,
+    providerId: chat.providerId,
+    reasoning: chat.reasoning ?? null,
+    title: chat.title ?? null,
+    origin: chat.origin ?? null,
+    subjectKey: chat.subjectKey ?? null,
+    subjectData: chatDataOfInput(chat) ?? null,
+    closed: chat.closed ?? null,
+    createdAt: chat.createdAt,
+    updatedAt: chat.updatedAt
+  };
+}
+function toChat(row) {
+  const { reasoning, title, origin, subjectKey, subjectData, closed, ...chat } = row;
+  return {
+    ...chat,
+    ...reasoning !== null && { reasoning },
+    ...title !== null && { title },
+    ...origin !== null && { origin },
+    ...subjectKey !== null && { subjectKey },
+    ...chatDataFields(subjectData),
+    ...closed !== null && { closed }
+  };
+}
+function subjectCondition(subjects = "exclude") {
+  if (subjects === "include") return void 0;
+  return subjects === "only" ? isNotNull(chats.subjectKey) : isNull(chats.subjectKey);
+}
+function dataConditions(filter) {
+  return Object.entries(filter ?? {}).map(([key, value]) => {
+    const typed = value === null ? sql2`type = 'null'` : typeof value === "string" ? sql2`type = 'text' and value = ${value}` : typeof value === "boolean" ? sql2`type = ${value ? "true" : "false"}` : sql2`type in ('integer', 'real') and value = ${value}`;
+    return sql2`exists (select 1 from json_each(${chats.subjectData}) where key = ${key} and ${typed})`;
+  });
+}
+function toMessage(row) {
+  const { seq: _seq, aliveAt: _aliveAt, afterTurn, ...message } = row;
+  return { ...message, ...afterTurn !== null && { afterTurn } };
+}
+function ownerNote(ownerId, id) {
+  return and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, id), isNull(memoryNotes.mergedInto));
+}
+function toOptimizationRun(row) {
+  return {
+    id: row.id,
+    startedAt: new Date(row.startedAt).toISOString(),
+    finishedAt: row.finishedAt === null ? null : new Date(row.finishedAt).toISOString(),
+    status: row.status,
+    groups: row.groups.map((group) => ({ ...group, originalIds: [...group.originalIds] })),
+    error: row.error,
+    usageRecordId: row.usageRecordId
+  };
+}
+function toMemoryNote(row) {
+  return {
+    id: row.id,
+    categories: [...row.categories],
+    content: row.content,
+    version: row.version,
+    createdAt: new Date(row.createdAt).toISOString(),
+    updatedAt: new Date(row.updatedAt).toISOString()
+  };
+}
+function isSubjectConflict(error) {
+  const { code, message, cause } = error ?? {};
+  return [code, cause?.code].includes("SQLITE_CONSTRAINT_UNIQUE") && [message, cause?.message].some((text2) => typeof text2 === "string" && text2.includes("chats.subject_key"));
+}
+function isPrimaryKeyConflict(error) {
+  const { code, cause } = error ?? {};
+  return [code, cause?.code].includes("SQLITE_CONSTRAINT_PRIMARYKEY");
+}
+export {
+  ForeignChatTablesError,
+  createSqliteChatStorage
+};
+//# sourceMappingURL=index.js.map