@ykurilov/agent-chat-storage-postgres 0.0.0-stage → 0.55.0

package/dist/index.js

@@ -0,0 +1,801 @@
+// src/postgres-storage.ts
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+import pg from "pg";
+
+// src/drizzle-chat-storage.ts
+import {
+  assertChatDataFilter,
+  assertKnownFormatVersion,
+  ChatAlreadyExistsError,
+  chatDataFields,
+  chatDataOfInput,
+  DuplicateChatSubjectError,
+  DuplicateMessageError,
+  isOptimizationBlocked,
+  mergeChatData,
+  MessageAlreadyFinishedError,
+  MessageNotAwaitingError,
+  RELEASED_ANSWER_ALIVE_AT,
+  revertRefusal,
+  sameMessageParts
+} from "@ykurilov/agent-chat-core";
+import { and, asc, desc, eq, gte, inArray, isNotNull, isNull, sql as sql2 } from "drizzle-orm";
+
+// src/schema.ts
+import { sql } from "drizzle-orm";
+import { bigint, boolean, doublePrecision, index, integer, json, jsonb, pgSchema, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+var agentChatSchema = pgSchema("agent_chat");
+var chats = agentChatSchema.table(
+  "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: json("subject_data").$type(),
+    /** Закрытие чата (`{ code, message }`); пусто — чат открыт. */
+    closed: json("closed").$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 = agentChatSchema.table(
+  "messages",
+  {
+    /** Порядок записи: сообщения с одинаковым временем создания отдаются по нему. */
+    seq: bigint("seq", { mode: "number" }).generatedAlwaysAsIdentity().notNull(),
+    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: json("parts").$type().notNull(),
+    formatVersion: integer("format_version").notNull(),
+    status: text("status").$type().notNull(),
+    modelId: text("model_id"),
+    providerId: text("provider_id"),
+    usage: json("usage").$type(),
+    reasoningDurationsMs: json("reasoning_durations_ms").$type().notNull(),
+    error: json("error").$type(),
+    /** Отметка обрыва озвучки (голосовой режим); пусто — озвучку не обрывали. */
+    voiceCut: json("voice_cut").$type(),
+    /** Состояние хука итога хода; пусто — хук не зовётся. */
+    afterTurn: text("after_turn", { enum: ["pending", "done", "failed"] }),
+    createdAt: text("created_at").notNull(),
+    /** Последний знак жизни идущего ответа (ISO); пусто — время создания. Только для восстановления, при чтении не отдаётся. */
+    aliveAt: text("alive_at")
+  },
+  (table) => [
+    index("messages_chat_created_idx").on(table.chatId, table.createdAt, 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 = agentChatSchema.table(
+  "compactions",
+  {
+    seq: bigint("seq", { mode: "number" }).generatedAlwaysAsIdentity().notNull(),
+    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: json("usage").$type(),
+    createdAt: text("created_at").notNull()
+  },
+  (table) => [index("compactions_chat_seq_idx").on(table.chatId, table.seq)]
+);
+var branchSelections = agentChatSchema.table(
+  "branch_selections",
+  {
+    seq: bigint("seq", { mode: "number" }).generatedAlwaysAsIdentity().notNull(),
+    id: text("id").primaryKey(),
+    chatId: text("chat_id").notNull().references(() => chats.id, { onDelete: "cascade" }),
+    messageId: text("message_id").notNull(),
+    selectedAt: text("selected_at").notNull()
+  },
+  (table) => [index("branch_selections_chat_seq_idx").on(table.chatId, table.seq)]
+);
+var usageRecords = agentChatSchema.table(
+  "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: bigint("input_tokens", { mode: "number" }).notNull(),
+    cachedInputTokens: bigint("cached_input_tokens", { mode: "number" }).notNull(),
+    cacheWriteTokens: bigint("cache_write_tokens", { mode: "number" }).notNull(),
+    outputTokens: bigint("output_tokens", { mode: "number" }).notNull(),
+    reasoningTokens: bigint("reasoning_tokens", { mode: "number" }).notNull(),
+    costUsd: doublePrecision("cost_usd").notNull(),
+    createdAt: text("created_at").notNull(),
+    /** Числа «примерно»: прикинуты по длине текста, а не сообщены провайдером. */
+    estimated: boolean("estimated").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 = agentChatSchema.table("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 = agentChatSchema.table("voice_choices", {
+  ownerId: text("owner_id").primaryKey(),
+  voiceId: text("voice_id").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var spendingLimitStates = agentChatSchema.table("spending_limit_states", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  version: integer("version").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var chatTurnLeases = agentChatSchema.table("chat_turn_leases", {
+  chatId: text("chat_id").primaryKey(),
+  holder: text("holder").notNull(),
+  until: timestamp("until", { withTimezone: true, mode: "string" }).notNull()
+});
+var memoryNotes = agentChatSchema.table(
+  "memory_notes",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    categories: jsonb("categories").$type().notNull(),
+    content: text("content").notNull(),
+    version: integer("version").notNull().default(1),
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "date" }).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 = agentChatSchema.table(
+  "memory_optimization_runs",
+  {
+    id: text("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    startedAt: timestamp("started_at", { withTimezone: true, mode: "date" }).notNull(),
+    finishedAt: timestamp("finished_at", { withTimezone: true, mode: "date" }),
+    status: text("status").$type().notNull(),
+    groups: jsonb("groups").$type().notNull().default(sql`'[]'::jsonb`),
+    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/drizzle-chat-storage.ts
+var storageSchema = { chats, messages, compactions, branchSelections, usageRecords, userModelChoices, voiceChoices, spendingLimitStates, memoryNotes, memoryOptimizationRuns };
+var StaleMerge = class extends Error {
+};
+function isoAtDatabase(moment) {
+  return sql2`to_char((${moment}) at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+}
+function aliveAtColumn(alive) {
+  if (!alive) return {};
+  return { aliveAt: alive === "released" ? RELEASED_ANSWER_ALIVE_AT : isoAtDatabase(sql2`now()`) };
+}
+function createDrizzleChatStorage(db) {
+  async function updateStreaming(messageId, { alive, ...values }) {
+    const updated = await db.update(messages).set({ ...values, ...aliveAtColumn(alive) }).where(and(eq(messages.id, messageId), eq(messages.status, "streaming"))).returning({ id: messages.id });
+    if (updated.length > 0) return;
+    const [existing] = await db.select({ id: messages.id }).from(messages).where(eq(messages.id, messageId));
+    if (!existing) throw new Error(`\u0421\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u044F ${messageId} \u043D\u0435\u0442`);
+    throw new MessageAlreadyFinishedError(messageId);
+  }
+  async function lockMemoryNotes(tx, ownerId) {
+    await tx.execute(sql2`select pg_advisory_xact_lock(hashtextextended(${`agent_chat.memory_notes:${ownerId}`}, 0))`);
+  }
+  async function visibleNotes(exec, ownerId) {
+    const rows = await exec.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), isNull(memoryNotes.mergedInto))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), sql2`${memoryNotes.id} collate "C" desc`);
+    return rows.map(toMemoryNote);
+  }
+  async function insertNotes(exec, ownerId, inputs) {
+    inputs.forEach(assertWellFormedNote);
+    if (inputs.length === 0) return [];
+    const now = /* @__PURE__ */ new Date();
+    const rows = await exec.insert(memoryNotes).values(
+      inputs.map(({ categories, content }) => ({
+        id: crypto.randomUUID(),
+        ownerId,
+        categories: [...categories],
+        content,
+        version: 1,
+        createdAt: now,
+        updatedAt: now
+      }))
+    ).returning();
+    return rows.map(toMemoryNote);
+  }
+  async function updateNote(exec, ownerId, id, expectedVersion, input) {
+    assertWellFormedNote(input);
+    const updated = await exec.update(memoryNotes).set({ categories: [...input.categories], content: input.content, version: sql2`${memoryNotes.version} + 1`, updatedAt: /* @__PURE__ */ new Date() }).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, id), eq(memoryNotes.version, expectedVersion), isNull(memoryNotes.mergedInto))).returning();
+    if (updated[0]) return toMemoryNote(updated[0]);
+    return await memoryNoteExists(exec, ownerId, id) ? "stale_version" : "not_found";
+  }
+  async function memoryNoteExists(exec, ownerId, id) {
+    const [existing] = await exec.select({ id: memoryNotes.id }).from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, id), isNull(memoryNotes.mergedInto)));
+    return existing !== void 0;
+  }
+  return {
+    async createChat({ createdAt, ...input }) {
+      const at = createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      const row = chatRow({ ...input, createdAt: at, updatedAt: at });
+      try {
+        await db.insert(chats).values(row);
+      } catch (error) {
+        if (isConflictOn(error, "chats_owner_subject_idx")) throw new DuplicateChatSubjectError(input.ownerId, input.subjectKey);
+        throw error;
+      }
+      return toChat(row);
+    },
+    async findChatBySubject(ownerId, subjectKey) {
+      const [row] = await db.select().from(chats).where(and(eq(chats.ownerId, ownerId), eq(chats.subjectKey, subjectKey)));
+      return row ? toChat(row) : null;
+    },
+    async importChat(chat, imported) {
+      await db.transaction(async (tx) => {
+        try {
+          await tx.insert(chats).values(chatRow(chat));
+        } catch (error) {
+          if (isConflictOn(error, "chats_owner_subject_idx")) throw new DuplicateChatSubjectError(chat.ownerId, chat.subjectKey);
+          if (isConflictOn(error, "chats_pkey")) throw new ChatAlreadyExistsError(chat.id);
+          throw error;
+        }
+        for (const message of imported) {
+          const { alive: _alive, ...stored } = message;
+          try {
+            await tx.insert(messages).values(stored);
+          } catch (error) {
+            if (isPrimaryKeyConflict(error)) throw new DuplicateMessageError(message.id);
+            throw error;
+          }
+        }
+      });
+    },
+    async setAfterTurnState(messageId, state, options) {
+      return db.transaction(async (tx) => {
+        const [existing] = await tx.select({ parts: messages.parts, afterTurn: messages.afterTurn }).from(messages).where(eq(messages.id, messageId)).for("update");
+        if (!existing || state !== "pending" && existing.afterTurn !== "pending") return false;
+        await tx.update(messages).set({
+          afterTurn: state,
+          ...options?.appendParts && { parts: [...existing.parts, ...options.appendParts] },
+          // Отметка ожидания хука — в колонке знака жизни, по часам базы: у законченного ответа она больше ни для чего.
+          ...state === "pending" && aliveAtColumn("now")
+        }).where(eq(messages.id, messageId));
+        return true;
+      });
+    },
+    async listPendingAfterTurn(filter) {
+      const pending = eq(messages.afterTurn, "pending");
+      const rows = await db.select({ id: messages.id }).from(messages).where(
+        filter?.pendingForMs === void 0 ? pending : and(
+          pending,
+          sql2`coalesce(${messages.aliveAt}, ${messages.createdAt}) < ${isoAtDatabase(sql2`now() - ${filter.pendingForMs} * interval '1 millisecond'`)}`
+        )
+      );
+      return rows.map((row) => row.id);
+    },
+    async getChat(chatId) {
+      const [chat] = await db.select().from(chats).where(eq(chats.id, chatId));
+      return chat ? toChat(chat) : null;
+    },
+    async updateChatModel(chatId, model) {
+      await db.update(chats).set({ modelId: model.modelId, providerId: model.providerId, reasoning: model.reasoning ?? null }).where(eq(chats.id, chatId));
+    },
+    async updateChatData(chatId, patch, { maxBytes }) {
+      return db.transaction(async (tx) => {
+        const [row] = await tx.select().from(chats).where(eq(chats.id, chatId)).for("update");
+        if (!row) return null;
+        const merged = mergeChatData(row.subjectData ?? void 0, patch, maxBytes);
+        await tx.update(chats).set({ subjectData: merged ?? null }).where(eq(chats.id, chatId));
+        return toChat({ ...row, subjectData: merged ?? null });
+      });
+    },
+    async listChats(ownerId, options) {
+      if (options?.data) assertChatDataFilter(options.data);
+      const rows = await db.select().from(chats).where(and(eq(chats.ownerId, ownerId), subjectCondition(options?.subjects), dataCondition(options?.data))).orderBy(desc(chats.updatedAt), desc(chats.createdAt), desc(chats.id));
+      return rows.map(toChat);
+    },
+    async renameChat(chatId, title) {
+      await db.update(chats).set({ title }).where(eq(chats.id, chatId));
+    },
+    async setChatClosed(chatId, closed) {
+      await db.update(chats).set({ closed: closed && { code: closed.code, message: closed.message } }).where(eq(chats.id, chatId));
+    },
+    async deleteChat(chatId) {
+      await db.transaction(async (tx) => {
+        await tx.delete(compactions).where(eq(compactions.chatId, chatId));
+        await tx.delete(branchSelections).where(eq(branchSelections.chatId, chatId));
+        await tx.delete(messages).where(eq(messages.chatId, chatId));
+        await tx.delete(chats).where(eq(chats.id, chatId));
+        await tx.delete(chatTurnLeases).where(eq(chatTurnLeases.chatId, chatId));
+      });
+    },
+    async claimChatTurn(chatId, holder, leaseMs) {
+      const until = sql2`now() + ${leaseMs} * interval '1 millisecond'`;
+      const claimed = await db.insert(chatTurnLeases).values({ chatId, holder, until }).onConflictDoUpdate({
+        target: chatTurnLeases.chatId,
+        set: { holder, until },
+        setWhere: sql2`${chatTurnLeases.holder} = ${holder} or ${chatTurnLeases.until} <= now()`
+      }).returning({ chatId: chatTurnLeases.chatId });
+      return claimed.length > 0;
+    },
+    async releaseChatTurn(chatId, holder) {
+      await db.delete(chatTurnLeases).where(and(eq(chatTurnLeases.chatId, chatId), eq(chatTurnLeases.holder, holder)));
+    },
+    async clearChatTurnLeases() {
+      await db.delete(chatTurnLeases);
+    },
+    async getMessage(messageId) {
+      const [row] = await db.select().from(messages).where(eq(messages.id, messageId));
+      if (!row) return null;
+      const message = toMessage(row);
+      assertKnownFormatVersion(message);
+      return message;
+    },
+    async listMessages(chatId) {
+      const rows = await db.select().from(messages).where(eq(messages.chatId, chatId)).orderBy(asc(messages.createdAt), asc(messages.seq));
+      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), asc(messages.seq));
+    },
+    // Части нужных типов выбираются внутри базы: тексты и выводы инструментов в процесс не идут.
+    async listMessagePartsOfTypes(chatId, types) {
+      const wanted = JSON.stringify([...types]);
+      const rows = await db.select({
+        id: messages.id,
+        parentId: messages.parentId,
+        createdAt: messages.createdAt,
+        parts: sql2`(select coalesce(json_agg(part.value order by part.position), '[]'::json) from json_array_elements(${messages.parts}) with ordinality as part(value, position) where part.value->>'type' in (select json_array_elements_text(${wanted}::json)))`
+      }).from(messages).where(eq(messages.chatId, chatId)).orderBy(asc(messages.createdAt), asc(messages.seq));
+      return rows.map((row) => ({ ...row, parts: typeof row.parts === "string" ? JSON.parse(row.parts) : row.parts }));
+    },
+    async insertMessage(message) {
+      try {
+        await db.transaction(async (tx) => {
+          const { alive, ...stored } = message;
+          await tx.insert(messages).values({ ...stored, ...aliveAtColumn(alive) });
+          await tx.update(chats).set({ updatedAt: message.createdAt }).where(eq(chats.id, message.chatId));
+        });
+      } catch (error) {
+        if (isPrimaryKeyConflict(error)) throw new DuplicateMessageError(message.id);
+        throw error;
+      }
+    },
+    updateStreamingMessage: (messageId, patch) => updateStreaming(messageId, patch),
+    markAnswerAlive: (messageId) => updateStreaming(messageId, { alive: "now" }),
+    finishMessage: (messageId, final) => updateStreaming(messageId, { ...final, ...final.afterTurn === "pending" && { alive: "now" } }),
+    async updateAwaitingMessage(messageId, patch) {
+      await db.transaction(async (tx) => {
+        const [existing] = await tx.select({ status: messages.status, parts: messages.parts }).from(messages).where(eq(messages.id, messageId)).for("update");
+        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);
+        await tx.update(messages).set({ parts: patch.parts, ...patch.status && { status: patch.status }, ...aliveAtColumn(patch.alive) }).where(eq(messages.id, messageId));
+      });
+    },
+    async listStreamingMessageIds() {
+      const rows = await db.select({ id: messages.id }).from(messages).where(eq(messages.status, "streaming")).orderBy(asc(messages.seq));
+      return rows.map((row) => row.id);
+    },
+    async listSilentAnswerIds({ silentForMs, chatId }) {
+      const silent = sql2`coalesce(${messages.aliveAt}, ${messages.createdAt}) < ${isoAtDatabase(sql2`now() - ${silentForMs} * interval '1 millisecond'`)}`;
+      const rows = await db.select({ id: messages.id }).from(messages).where(and(eq(messages.status, "streaming"), silent, chatId === void 0 ? void 0 : eq(messages.chatId, chatId))).orderBy(asc(messages.seq));
+      return rows.map((row) => row.id);
+    },
+    async insertCompaction(record) {
+      await db.insert(compactions).values(record);
+    },
+    async listCompactions(chatId) {
+      const rows = await db.select().from(compactions).where(eq(compactions.chatId, chatId)).orderBy(asc(compactions.seq));
+      return rows.map(({ seq: _seq, ...record }) => record);
+    },
+    async insertBranchSelection(record) {
+      await db.insert(branchSelections).values(record);
+    },
+    async listBranchSelections(chatId) {
+      const rows = await db.select().from(branchSelections).where(eq(branchSelections.chatId, chatId)).orderBy(asc(branchSelections.seq));
+      return rows.map(({ seq: _seq, ...record }) => record);
+    },
+    async insertUsageRecord(record) {
+      await db.insert(usageRecords).values(record);
+    },
+    async hasUsageRecord(id) {
+      const rows = await db.select({ id: usageRecords.id }).from(usageRecords).where(eq(usageRecords.id, id)).limit(1);
+      return rows.length > 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);
+    },
+    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);
+    },
+    async getUserModelChoice(ownerId) {
+      const [row] = await db.select().from(userModelChoices).where(eq(userModelChoices.ownerId, ownerId));
+      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() };
+      await db.insert(userModelChoices).values({ ownerId, ...values }).onConflictDoUpdate({ target: userModelChoices.ownerId, set: values });
+    },
+    async setVoiceCut({ ownerId, chatId, messageId, voiceCut }) {
+      await 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})`
+        )
+      );
+    },
+    async getSpendingLimitState(key) {
+      const [row] = await db.select().from(spendingLimitStates).where(eq(spendingLimitStates.key, key));
+      return row ? { value: row.value, version: row.version } : null;
+    },
+    // Одна команда без чтения: вставка или правка срабатывает только при совпавшей версии, из двух одновременных проходит одна.
+    async saveSpendingLimitState(key, value, expectedVersion) {
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (expectedVersion === null) {
+        const inserted = await db.insert(spendingLimitStates).values({ key, value, version: 1, updatedAt }).onConflictDoNothing().returning({ key: spendingLimitStates.key });
+        return inserted.length === 1;
+      }
+      const updated = await db.update(spendingLimitStates).set({ value, version: expectedVersion + 1, updatedAt }).where(and(eq(spendingLimitStates.key, key), eq(spendingLimitStates.version, expectedVersion))).returning({ key: spendingLimitStates.key });
+      return updated.length === 1;
+    },
+    async deleteSpendingLimitStates(keys) {
+      if (keys.length > 0) await db.delete(spendingLimitStates).where(inArray(spendingLimitStates.key, keys));
+    },
+    async getVoiceChoice(ownerId) {
+      const [row] = await db.select().from(voiceChoices).where(eq(voiceChoices.ownerId, ownerId));
+      return row?.voiceId ?? null;
+    },
+    async setVoiceChoice(ownerId, voiceId) {
+      const values = { voiceId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      await db.insert(voiceChoices).values({ ownerId, ...values }).onConflictDoUpdate({ target: voiceChoices.ownerId, set: values });
+    },
+    async listMemoryNotes(ownerId) {
+      return visibleNotes(db, ownerId);
+    },
+    async insertMemoryNotes(ownerId, inputs) {
+      return insertNotes(db, ownerId, inputs);
+    },
+    async insertMemoryNotesChecked(ownerId, inputs, guard) {
+      return db.transaction(async (tx) => {
+        await lockMemoryNotes(tx, ownerId);
+        const error = guard(await visibleNotes(tx, ownerId));
+        return error ?? await insertNotes(tx, ownerId, inputs);
+      });
+    },
+    async updateMemoryNote(ownerId, id, expectedVersion, input) {
+      return updateNote(db, ownerId, id, expectedVersion, input);
+    },
+    async updateMemoryNoteChecked(ownerId, id, expectedVersion, input, guard) {
+      return db.transaction(async (tx) => {
+        await lockMemoryNotes(tx, ownerId);
+        const error = guard(await visibleNotes(tx, ownerId));
+        return error ?? await updateNote(tx, ownerId, id, expectedVersion, input);
+      });
+    },
+    async deleteMemoryNote(ownerId, id, expectedVersion) {
+      const deleted = await db.transaction(async (tx) => {
+        const rows = await tx.delete(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, id), eq(memoryNotes.version, expectedVersion), isNull(memoryNotes.mergedInto))).returning({ id: memoryNotes.id });
+        if (rows.length > 0) await tx.delete(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, id)));
+        return rows.length > 0;
+      });
+      if (deleted) return "ok";
+      return await memoryNoteExists(db, ownerId, id) ? "stale_version" : "not_found";
+    },
+    async clearMemoryNotes(ownerId) {
+      return db.transaction(async (tx) => {
+        const deleted = await tx.delete(memoryNotes).where(eq(memoryNotes.ownerId, ownerId)).returning({ mergedInto: memoryNotes.mergedInto });
+        await tx.delete(memoryOptimizationRuns).where(eq(memoryOptimizationRuns.ownerId, ownerId));
+        return deleted.filter((row) => row.mergedInto === null).length;
+      });
+    },
+    // Взятие запуска — одна транзакция под замком человека: проверка правил и вставка не разрываются между процессами.
+    async claimMemoryOptimizationRun(ownerId, rules, now) {
+      const nowMs = Date.parse(now);
+      return db.transaction(async (tx) => {
+        await tx.execute(sql2`select pg_advisory_xact_lock(hashtextextended(${`agent_chat.memory_optimization:${ownerId}`}, 0))`);
+        const runs = await tx.select().from(memoryOptimizationRuns).where(eq(memoryOptimizationRuns.ownerId, ownerId));
+        const state = runs.map((run) => {
+          const leaseEnd = run.startedAt.getTime() + rules.leaseMs;
+          const expired = run.status === "running" && nowMs >= leaseEnd;
+          return { status: expired ? "failed" : run.status, endedAt: expired ? leaseEnd : (run.finishedAt ?? run.startedAt).getTime(), expired, id: run.id };
+        });
+        for (const run of state.filter((item) => item.expired)) {
+          await tx.update(memoryOptimizationRuns).set({ status: "failed", error: "lease_expired", finishedAt: new Date(run.endedAt) }).where(eq(memoryOptimizationRuns.id, run.id));
+        }
+        const blocked = isOptimizationBlocked(
+          runs.map((run, index2) => ({ status: state[index2].status, startedAtMs: run.startedAt.getTime(), endedAtMs: state[index2].endedAt })),
+          rules,
+          nowMs
+        );
+        if (blocked) return null;
+        const [created] = await tx.insert(memoryOptimizationRuns).values({ id: crypto.randomUUID(), ownerId, startedAt: new Date(nowMs), status: "running" }).returning();
+        return toOptimizationRun(created);
+      });
+    },
+    async finishMemoryOptimizationRun(ownerId, runId, outcome) {
+      const finished = await db.update(memoryOptimizationRuns).set({ status: outcome.status, finishedAt: new Date(outcome.finishedAt), error: outcome.error ?? null, usageRecordId: outcome.usageRecordId ?? null }).where(and(eq(memoryOptimizationRuns.id, runId), eq(memoryOptimizationRuns.ownerId, ownerId), eq(memoryOptimizationRuns.status, "running"))).returning({ id: memoryOptimizationRuns.id });
+      return finished.length > 0 ? "ok" : "not_found";
+    },
+    // Слияние — одна транзакция: несошедшийся оригинал бросает StaleMerge, и откатывается всё, включая запуск.
+    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 { result, originals } of merges) {
+        assertWellFormedNote(result);
+        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);
+        }
+      }
+      try {
+        return await db.transaction(async (tx) => {
+          const [run] = await tx.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.id, merge.runId), eq(memoryOptimizationRuns.ownerId, ownerId))).for("update");
+          if (run?.status !== "running") return "run_not_active";
+          const now = /* @__PURE__ */ new Date();
+          const groups = [];
+          for (const { result, originals } of merges) {
+            const created = { id: crypto.randomUUID(), ownerId, categories: [...result.categories], content: result.content, version: 1, createdAt: now, updatedAt: now };
+            await tx.insert(memoryNotes).values(created);
+            for (const { id, version } of originals) {
+              const hidden = await tx.update(memoryNotes).set({ mergedInto: created.id }).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, id), eq(memoryNotes.version, version), isNull(memoryNotes.mergedInto))).returning({ id: memoryNotes.id });
+              if (hidden.length === 0) throw new StaleMerge();
+            }
+            groups.push({ resultId: created.id, originalIds: originals.map(({ id }) => id), resultVersion: 1 });
+          }
+          const [finished] = await tx.update(memoryOptimizationRuns).set({ status: "applied", finishedAt: new Date(merge.finishedAt), groups, usageRecordId: merge.usageRecordId ?? null }).where(eq(memoryOptimizationRuns.id, run.id)).returning();
+          return toOptimizationRun(finished);
+        });
+      } catch (error) {
+        if (error instanceof StaleMerge) return "stale_version";
+        throw error;
+      }
+    },
+    async revertMemoryMerge(ownerId, runId, guard) {
+      return db.transaction(async (tx) => {
+        await lockMemoryNotes(tx, ownerId);
+        const [run] = await tx.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.id, runId), eq(memoryOptimizationRuns.ownerId, ownerId))).for("update");
+        if (run?.status !== "applied") return "not_found";
+        for (const { resultId, originalIds, resultVersion } of run.groups) {
+          const [result] = await tx.select({ version: memoryNotes.version }).from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, resultId), isNull(memoryNotes.mergedInto))).for("update");
+          if (result?.version !== resultVersion) return "conflict";
+          const hidden = await tx.select({ id: memoryNotes.id }).from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, resultId), inArray(memoryNotes.id, originalIds))).for("update");
+          if (hidden.length !== originalIds.length) return "conflict";
+        }
+        if (guard) {
+          const resultIds = run.groups.map(({ resultId }) => resultId);
+          const remaining = (await visibleNotes(tx, ownerId)).filter((note) => !resultIds.includes(note.id));
+          const restoredRows = await tx.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), inArray(memoryNotes.mergedInto, resultIds))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), sql2`${memoryNotes.id} collate "C" desc`);
+          const error = guard(remaining, restoredRows.map(toMemoryNote));
+          if (error) return revertRefusal(error);
+        }
+        for (const { resultId } of run.groups) {
+          await tx.update(memoryNotes).set({ mergedInto: null }).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.mergedInto, resultId)));
+          await tx.delete(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), eq(memoryNotes.id, resultId)));
+        }
+        await tx.update(memoryOptimizationRuns).set({ status: "reverted" }).where(eq(memoryOptimizationRuns.id, run.id));
+        return "ok";
+      });
+    },
+    async listMemoryOptimizationRuns(ownerId, filter) {
+      const query = db.select().from(memoryOptimizationRuns).where(and(eq(memoryOptimizationRuns.ownerId, ownerId), ...filter?.status ? [inArray(memoryOptimizationRuns.status, filter.status)] : [])).orderBy(desc(memoryOptimizationRuns.startedAt), sql2`${memoryOptimizationRuns.id} collate "C" desc`);
+      const rows = await (filter?.limit === void 0 ? query : query.limit(filter.limit));
+      return rows.map(toOptimizationRun);
+    },
+    async listMergedMemoryNotes(ownerId) {
+      const rows = await db.select().from(memoryNotes).where(and(eq(memoryNotes.ownerId, ownerId), isNotNull(memoryNotes.mergedInto))).orderBy(desc(memoryNotes.updatedAt), desc(memoryNotes.createdAt), sql2`${memoryNotes.id} collate "C" desc`);
+      return rows.map((row) => ({ ...toMemoryNote(row), mergedInto: row.mergedInto }));
+    }
+  };
+}
+function isPrimaryKeyConflict(error) {
+  return isConflictOn(error, "messages_pkey");
+}
+function isConflictOn(error, constraintName) {
+  const { code, constraint, cause } = error ?? {};
+  return [code, cause?.code].includes("23505") && [constraint, cause?.constraint].includes(constraintName);
+}
+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 dataCondition(filter) {
+  if (!filter || Object.keys(filter).length === 0) return void 0;
+  return sql2`${chats.subjectData}::jsonb @> ${JSON.stringify(filter)}::jsonb`;
+}
+function toMessage(row) {
+  const { seq: _seq, aliveAt: _aliveAt, afterTurn, ...message } = row;
+  return { ...message, ...afterTurn !== null && { afterTurn } };
+}
+function toMemoryNote(row) {
+  return {
+    id: row.id,
+    categories: [...row.categories],
+    content: row.content,
+    version: row.version,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+function toOptimizationRun(row) {
+  return {
+    id: row.id,
+    startedAt: row.startedAt.toISOString(),
+    finishedAt: row.finishedAt ? row.finishedAt.toISOString() : null,
+    status: row.status,
+    groups: row.groups.map((group) => ({ ...group, originalIds: [...group.originalIds] })),
+    error: row.error,
+    usageRecordId: row.usageRecordId
+  };
+}
+function assertWellFormedNote(note) {
+  if (!Array.isArray(note?.categories) || !note.categories.every((category) => typeof category === "string")) {
+    throw new TypeError("\u0420\u0430\u0437\u0434\u0435\u043B\u044B \u0437\u0430\u043F\u0438\u0441\u0438 \u043F\u0430\u043C\u044F\u0442\u0438 \u2014 \u0441\u043F\u0438\u0441\u043E\u043A \u0441\u0442\u0440\u043E\u043A");
+  }
+  if (typeof note.content !== "string") throw new TypeError("\u0422\u0435\u043A\u0441\u0442 \u0437\u0430\u043F\u0438\u0441\u0438 \u043F\u0430\u043C\u044F\u0442\u0438 \u2014 \u0441\u0442\u0440\u043E\u043A\u0430");
+}
+
+// src/migrate.ts
+import { fileURLToPath } from "url";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+var migrationsFolder = fileURLToPath(new URL("../drizzle", import.meta.url));
+var MIGRATION_LOCK_KEY = 7311900442;
+async function migrateToLatest(pool) {
+  const client = await pool.connect();
+  try {
+    await client.query("select pg_advisory_lock($1)", [MIGRATION_LOCK_KEY]);
+    try {
+      await migrate(drizzle(client), { migrationsFolder, migrationsSchema: "agent_chat" });
+    } finally {
+      await client.query("select pg_advisory_unlock($1)", [MIGRATION_LOCK_KEY]);
+    }
+  } finally {
+    client.release();
+  }
+}
+
+// src/postgres-storage.ts
+var DEFAULT_POOL_SIZE = 10;
+async function createPostgresChatStorage(options) {
+  const logError = options.logError ?? ((message) => console.error(message));
+  const pool = new pg.Pool({ connectionString: options.connectionString, max: options.poolSize ?? DEFAULT_POOL_SIZE });
+  pool.on("error", (error) => logError(`PostgreSQL: \u0441\u043E\u0435\u0434\u0438\u043D\u0435\u043D\u0438\u0435 \u043E\u0431\u043E\u0440\u0432\u0430\u043B\u043E\u0441\u044C: ${error.message}`));
+  try {
+    await pool.query("select 1");
+  } catch (error) {
+    await pool.end().catch(() => {
+    });
+    throw failure("\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u044C\u0441\u044F \u043A PostgreSQL", options.connectionString, error);
+  }
+  try {
+    await migrateToLatest(pool);
+  } catch (error) {
+    await pool.end().catch(() => {
+    });
+    throw failure("\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442\u044C \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0438 PostgreSQL", options.connectionString, error);
+  }
+  return {
+    ...createDrizzleChatStorage(drizzle2(pool, { schema: storageSchema })),
+    async close() {
+      await pool.end();
+    }
+  };
+}
+function failure(summary, connectionString, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  let place = "\u0430\u0434\u0440\u0435\u0441 \u043D\u0435 \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u043D";
+  try {
+    const address = new URL(connectionString);
+    place = `${address.hostname}:${address.port || "5432"}${address.pathname}`;
+  } catch {
+  }
+  const safeReason = reason.split(connectionString).join("<\u0441\u0442\u0440\u043E\u043A\u0430 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F>");
+  return new Error(`${summary} (${place}): ${safeReason}`);
+}
+export {
+  createPostgresChatStorage
+};
+//# sourceMappingURL=index.js.map