@ykurilov/agent-chat-sandbox 0.0.0-stage → 0.55.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yury Kurilov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,60 @@
-# Temporary Holding Version
+# @ykurilov/agent-chat-sandbox
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Песочница агента для админа приложения: чат с боевым агентом, журнал каждого обращения к модели и вызова инструмента,
+правка любого сообщения с веткой, своя модель и своя системная инструкция на чат. Отдельное расширение: приложению без
+песочницы пакет не нужен, и в боевом чате ничего не меняется (ни таблиц, ни записи журнала).
+
+`react`, `@ykurilov/agent-chat-react`, `better-sqlite3` и `pg` — необязательные зависимости (peer): ставьте те, что нужны.
+
+## Сервер
+
+```ts
+import { createSandboxHandler } from "@ykurilov/agent-chat-sandbox";
+import { createSqliteSandboxJournal } from "@ykurilov/agent-chat-sandbox/sqlite"; // или …/postgres
+import { mountChat } from "@ykurilov/agent-chat-server/hono";
+
+mountChat(app, createChatHandler(chatOptions));
+mountChat(app, createSandboxHandler({
+  chat: chatOptions, // те же настройки, что у боевого чата
+  isAdmin: (user) => adminIds.has(user.id), // на каждом запросе; не админ получает 404
+  journal: await createSqliteSandboxJournal({ filePath: "app.sqlite" }),
+}));
+```
+
+Next.js: `createNextRouteHandlers(sandboxHandler)` в `app/api/sandbox/[[...path]]/route.ts`.
+
+## Экран
+
+```tsx
+import { AgentSandbox } from "@ykurilov/agent-chat-sandbox/react";
+import { tandemSandboxSkin } from "@ykurilov/agent-chat-skin-tandem/sandbox";
+
+<AgentSandbox skin={tandemSkin} sandboxSkin={tandemSandboxSkin} chatListSkin={tandemSkin} chatProps={{ attachments, images, videos }} />
+```
+
+## Что важно знать
+
+- **Доступ.** `resolveUser` → `isAdmin` на каждом запросе, результат не кэшируется. Песочные чаты личные: владелец
+  `sandbox:<id админа>`, боевые адреса, списки и траты их не видят. `isSandboxOwner(ownerId)` отделяет их в отчётах о тратах.
+- **Журнал.** Таблицы `sandbox_*` в SQLite или PostgreSQL (`createMemorySandboxJournal` для тестов), миграции сами. Живёт 30 дней
+  (`retentionDays`), удаляется вместе с чатом. Запись не задерживает ответ; ключи из окружения (по именам KEY, TOKEN, SECRET… от 8 знаков), пароли из адресов подключения и заголовки не пишутся.
+- **Память только на чтение.** Агент видит боевую память админа, записать ничего не может; экран памяти в песочнице закрыт.
+- **Правка ответа.** Меняются текст и результаты обычных инструментов; вызовы, картинки, видео и ответы на виджеты остаются,
+  рассуждения убираются. `chat.lockedToolOutputs` добавляет инструменты, чей результат менять нельзя.
+- **Инструменты.** В `agent.tools(model)` приходит настоящий `ownerId` админа. Инструментам из `chatOwnedTools` (по умолчанию
+  `generate_images`) — песочный владелец: файлы и траты принадлежат песочному чату.
+- **Закрытый чат.** Инструмент закрывает песочный чат так же, как боевой: видно, что закрытие работает. Продолжить тест —
+  кнопка «Открыть чат снова» (`POST {sandboxBase}/chats/:chatId/reopen`) или новая копия чата человека: она всегда открыта.
+  Права приложения (`chatCapabilities`) и `beforeCreateChat` песочница не применяет.
+- **Осторожно.** Инструменты приложения в песочнице выполняются по-настоящему от имени админа (письма, платежи, запись в базу). Опасные подмените заглушками: см. docs/sandbox.md, «Инструменты агента».
+- **Чаты людей.** Только с опцией `people` у обработчика и `people` у `AgentSandbox`: `people: { find }` — человека ищет
+  приложение, `people: true` — его id вводят вручную. Без опции раздела нет, экран прежний. Чат человека только читается;
+  «Проверить в копии» делает песочный чат админа, агент в нём читает память человека. В копии `agent.tools(model)` получает
+  `ownerId` человека, `model.staff` и объект исходного чата (`model.subject`, ключ копии наружу не идёт): при
+  `model.staff` любая запись в данные `ownerId` запрещена — это обязанность инструментов приложения, ядро их записи
+  не перехватывает. `afterTurn` приложения зовётся только в копии, так же с `staff`, человеком и его объектом: при
+  `turn.staff` в данные человека не писать. В обычном песочном чате `afterTurn` и `beforeTurn` не зовутся.
+- **Лимиты.** Картинки считаются на песочного владельца по правилам приложения; у модели лимит только если задан
+  `createSandboxHandler({ limits })`.
+
+Подробно — [docs/sandbox.md](../../docs/sandbox.md). Живая проверка: `pnpm test:live sandbox`.

package/dist/chunk-4O5NPJOS.js

@@ -0,0 +1,483 @@
+// src/journal/hide-secrets.ts
+var HIDDEN = "[\u0441\u043A\u0440\u044B\u0442\u043E]";
+var MIN_ENV_SECRET_LENGTH = 8;
+var MIN_URL_PASSWORD_LENGTH = 6;
+var SECRET_ENV_NAME = /KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|AUTH|CREDENTIAL|PRIVATE/i;
+var URL_WITH_PASSWORD = /^[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:([^@\s]+)@/i;
+var MIN_FIELD_SECRET_LENGTH = 4;
+var MIN_ENCODED_LENGTH = 16;
+var SECRET_FIELD_NAME = /^(authorization|proxy-authorization|x-api-key|x-goog-api-key|api[-_]?key|apikey|access[-_]?token|auth[-_]?token|refresh[-_]?token|token|secret|client[-_]?secret|password|passwd|bearer|cookie|set-cookie)$/i;
+var BASE64_LIKE = /^[A-Za-z0-9+/_-]+={0,2}$/;
+function createSecretHider(options = {}) {
+  let fixed = unique([...secretsFromEnv(options.env ?? process.env), ...options.secrets ?? []]);
+  let bySettings = /* @__PURE__ */ new WeakMap();
+  let bySecrets = /* @__PURE__ */ new Map();
+  return {
+    forSettings(settings) {
+      const cached = settings !== null && typeof settings === "object" ? bySettings.get(settings) : void 0;
+      if (cached) return cached;
+      const secrets = unique([...fixed, ...secretFieldValues(settings)]);
+      const key = secrets.join("\0");
+      let hider = bySecrets.get(key);
+      if (!hider) {
+        hider = buildHider(secrets);
+        if (bySecrets.size >= MAX_CACHED_HIDERS) bySecrets.delete(bySecrets.keys().next().value);
+        bySecrets.set(key, hider);
+      }
+      if (settings !== null && typeof settings === "object") bySettings.set(settings, hider);
+      return hider;
+    },
+    addSecrets(values) {
+      const added = values.filter((value) => value.length > 0);
+      fixed = unique([...fixed, ...added]);
+      bySettings = /* @__PURE__ */ new WeakMap();
+      bySecrets = /* @__PURE__ */ new Map();
+    }
+  };
+}
+var MAX_CACHED_HIDERS = 16;
+function secretsFromEnv(env) {
+  const found = [];
+  for (const [name, value] of Object.entries(env)) {
+    if (typeof value !== "string") continue;
+    if (SECRET_ENV_NAME.test(name) && value.length >= MIN_ENV_SECRET_LENGTH) found.push(value);
+    const password = URL_WITH_PASSWORD.exec(value)?.[1];
+    if (password && password.length >= MIN_URL_PASSWORD_LENGTH) {
+      found.push(password);
+      try {
+        found.push(decodeURIComponent(password));
+      } catch {
+      }
+      if (value.length >= MIN_ENV_SECRET_LENGTH) found.push(value);
+    }
+  }
+  return found;
+}
+function buildHider(secrets) {
+  const raw = withVariants(secrets);
+  const escaped = escapedVariants(secrets);
+  function hideInString(text) {
+    let result = text;
+    for (const secret of raw) if (result.includes(secret)) result = result.split(secret).join(HIDDEN);
+    if (result.length >= MIN_ENCODED_LENGTH && BASE64_LIKE.test(result) && decodesToSecret(result, secrets)) return HIDDEN;
+    return result;
+  }
+  function walk(value, onKey) {
+    if (typeof value === "string") return hideInString(value);
+    if (Array.isArray(value)) return value.map((item) => walk(item, onKey));
+    if (value !== null && typeof value === "object") {
+      const copy = {};
+      for (const [key, child] of Object.entries(value)) {
+        const replaced = onKey?.(key, child);
+        copy[hideInString(key)] = replaced !== void 0 ? replaced : walk(child, onKey);
+      }
+      return copy;
+    }
+    return value;
+  }
+  return {
+    value: (value) => secrets.length === 0 ? value : walk(value),
+    settings: (settings) => walk(settings, (key, child) => SECRET_FIELD_NAME.test(key) && typeof child === "string" ? HIDDEN : void 0),
+    text(text) {
+      let result = text;
+      for (const secret of escaped) if (result.includes(secret)) result = result.split(secret).join(HIDDEN);
+      return result;
+    }
+  };
+}
+function secretFieldValues(value, found = []) {
+  if (Array.isArray(value)) {
+    for (const item of value) secretFieldValues(item, found);
+  } else if (value !== null && typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      if (SECRET_FIELD_NAME.test(key) && typeof child === "string") {
+        const trimmed = child.trim();
+        if (trimmed.length >= MIN_FIELD_SECRET_LENGTH) found.push(trimmed);
+        const token = /^(?:bearer|basic|token)\s+(\S+)$/i.exec(trimmed)?.[1];
+        if (token && token.length >= MIN_FIELD_SECRET_LENGTH) found.push(token);
+      } else {
+        secretFieldValues(child, found);
+      }
+    }
+  }
+  return found;
+}
+function withVariants(secrets) {
+  const variants = secrets.flatMap((secret) => [secret, Buffer.from(secret).toString("base64"), encodeURIComponent(secret)]);
+  return unique(variants).filter((variant) => variant.length > 0).sort((a, b) => b.length - a.length);
+}
+function escapedVariants(secrets) {
+  const variants = secrets.flatMap((secret) => {
+    const once = JSON.stringify(secret).slice(1, -1);
+    const twice = JSON.stringify(once).slice(1, -1);
+    return [secret, once, twice];
+  });
+  return unique(variants).sort((a, b) => b.length - a.length);
+}
+function decodesToSecret(text, secrets) {
+  let decoded;
+  try {
+    decoded = Buffer.from(text.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+  } catch {
+    return false;
+  }
+  return secrets.some((secret) => decoded.includes(secret));
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/journal/journal-blobs.ts
+import { createHash } from "crypto";
+import { promisify } from "util";
+import { gunzip as gunzipCallback, gzip as gzipCallback } from "zlib";
+var gzip = promisify(gzipCallback);
+var gunzip = promisify(gunzipCallback);
+var BLOB_LIMIT_BYTES = 256 * 1024;
+var MIN_BARE_BASE64_LENGTH = 1024;
+var BARE_BASE64 = /^[A-Za-z0-9+/_-]+={0,2}$/;
+var DATA_URL = /^data:([^;,]*)(;[^,]*)?,/;
+function describeSize(bytes) {
+  if (bytes < 1024) return `${bytes} \u0411`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} \u041A\u0411`;
+  return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} \u041C\u0411`;
+}
+async function prepareBlob(value, hider) {
+  if (value === null || typeof value !== "object") return packText(hider.text(JSON.stringify(hider.value(toPlain(value))) ?? "null"));
+  const byObject = preparedBlobs.get(hider) ?? /* @__PURE__ */ new WeakMap();
+  preparedBlobs.set(hider, byObject);
+  const cached = byObject.get(value);
+  if (cached) return cached;
+  const prepared = packText(hider.text(JSON.stringify(hider.value(toPlain(value))) ?? "null"));
+  byObject.set(value, prepared);
+  prepared.catch(() => byObject.delete(value));
+  return prepared;
+}
+var preparedBlobs = /* @__PURE__ */ new WeakMap();
+async function packText(text) {
+  const hash = createHash("sha256").update(text).digest("hex");
+  const bytes = Buffer.byteLength(text);
+  const truncated = bytes > BLOB_LIMIT_BYTES;
+  const stored = truncated ? JSON.stringify(cut(text, bytes)) : text;
+  return { hash, data: await gzip(Buffer.from(stored)), bytes, truncated };
+}
+function cut(text, bytes) {
+  const head = Buffer.from(text).subarray(0, BLOB_LIMIT_BYTES).toString("utf8").replace(/�+$/, "");
+  return `${head}
+\u2026[\u043E\u0431\u0440\u0435\u0437\u0430\u043D\u043E: \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u043E ${describeSize(Buffer.byteLength(head))} \u0438\u0437 ${describeSize(bytes)}]`;
+}
+async function unpackBlob(row) {
+  const text = (await gunzip(row.data)).toString("utf8");
+  return { hash: row.hash, content: JSON.parse(text), bytes: row.bytes, truncated: row.truncated };
+}
+async function splitModelCall(event, hider) {
+  const { request, response } = event;
+  const eventHider = hider;
+  const settings = await packText(eventHider.text(JSON.stringify(eventHider.settings(toPlain(request.settings))) ?? "null"));
+  const instructions = await prepareBlob(request.instructions, eventHider);
+  const messages = await Promise.all(request.messages.map((message) => prepareBlob(message, eventHider)));
+  const tools = await prepareBlob(request.tools, eventHider);
+  const answer = await prepareBlob(response, eventHider);
+  const row = {
+    id: event.callId,
+    chatId: event.chatId,
+    ownerId: event.ownerId,
+    messageId: event.messageId,
+    purpose: event.purpose,
+    attempt: event.attempt,
+    modelId: event.modelId,
+    providerId: event.providerId,
+    usage: event.usage,
+    costUsd: event.costUsd,
+    startedAt: event.startedAt,
+    firstChunkMs: event.firstChunkMs,
+    durationMs: event.durationMs,
+    status: event.status,
+    error: hideText(event.error, eventHider),
+    instructionsHash: instructions.hash,
+    messageHashes: messages.map((blob) => blob.hash),
+    toolsHash: tools.hash,
+    settingsHash: settings.hash,
+    responseHash: answer.hash,
+    toolCallIds: response.toolCalls.map((call) => call.toolCallId)
+  };
+  return { row, blobs: uniqueBlobs([instructions, ...messages, tools, settings, answer]) };
+}
+async function splitToolCall(event, hider) {
+  const input = await prepareBlob(event.input, hider);
+  const output = event.output === void 0 ? null : await prepareBlob(event.output, hider);
+  const row = {
+    id: crypto.randomUUID(),
+    chatId: event.chatId,
+    ownerId: event.ownerId,
+    messageId: event.messageId,
+    toolCallId: event.toolCallId,
+    toolName: event.toolName,
+    inputHash: input.hash,
+    outputHash: output?.hash ?? null,
+    error: hideText(event.error, hider),
+    startedAt: event.startedAt,
+    durationMs: event.durationMs
+  };
+  return { row, blobs: uniqueBlobs(output ? [input, output] : [input]) };
+}
+function hideText(text, hider) {
+  return text === null ? null : hider.text(String(hider.value(text)));
+}
+function uniqueBlobs(blobs) {
+  return [...new Map(blobs.map((blob) => [blob.hash, blob])).values()];
+}
+var BINARY_KINDS = [
+  ["image/", "\u043A\u0430\u0440\u0442\u0438\u043D\u043A\u0430"],
+  ["audio/", "\u0437\u0432\u0443\u043A"],
+  ["video/", "\u0432\u0438\u0434\u0435\u043E"]
+];
+function describeBinary(mediaType, bytes) {
+  const kind = BINARY_KINDS.find(([prefix]) => mediaType?.startsWith(prefix))?.[1] ?? (mediaType ? "\u0444\u0430\u0439\u043B" : "\u0434\u0432\u043E\u0438\u0447\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435");
+  return [kind, mediaType, describeSize(bytes)].filter((part) => part !== null).join(", ");
+}
+function binaryLength(value) {
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  return null;
+}
+function base64Bytes(text) {
+  const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(text.length * 3 / 4) - padding);
+}
+function toPlain(value, seen = /* @__PURE__ */ new WeakSet(), mediaType = null) {
+  if (typeof value === "string") return plainString(value, mediaType);
+  if (value === null || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (value === void 0 || typeof value === "function" || typeof value === "symbol") return void 0;
+  const length = binaryLength(value);
+  if (length !== null) return describeBinary(mediaType, length);
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (value instanceof URL) return value.href;
+  if (value instanceof Error) return { name: value.name, message: value.message };
+  const object = value;
+  if (seen.has(object)) return "[\u0446\u0438\u043A\u043B]";
+  seen.add(object);
+  try {
+    if (Array.isArray(object)) return object.map((item) => toPlain(item, seen, mediaType) ?? null);
+    const record = object;
+    const ownType = typeof record.mediaType === "string" ? record.mediaType : typeof record.mimeType === "string" ? record.mimeType : null;
+    const copy = {};
+    for (const [key, child] of Object.entries(record)) {
+      const plain = toPlain(child, seen, key === "data" || key === "image" ? ownType : null);
+      if (plain !== void 0) copy[key] = plain;
+    }
+    return copy;
+  } finally {
+    seen.delete(object);
+  }
+}
+function plainString(text, mediaType) {
+  const dataUrl = DATA_URL.exec(text);
+  if (dataUrl) return describeBinary(dataUrl[1] || null, dataUrl[2]?.includes("base64") ? base64Bytes(text.slice(dataUrl[0].length)) : Buffer.byteLength(text) - dataUrl[0].length);
+  if (text.length >= MIN_BARE_BASE64_LENGTH && BARE_BASE64.test(text)) return describeBinary(mediaType, base64Bytes(text));
+  if (mediaType && text.length >= 64 && BARE_BASE64.test(text)) return describeBinary(mediaType, base64Bytes(text));
+  return text;
+}
+
+// src/journal/journal.ts
+var QUEUE_LIMIT = 1e3;
+var DELETED_CHATS_LIMIT = 1e4;
+var MISSING_BLOB = "[\u043A\u0443\u0441\u043E\u043A \u0436\u0443\u0440\u043D\u0430\u043B\u0430 \u0443\u0434\u0430\u043B\u0451\u043D]";
+function createSandboxJournal(store, options = {}) {
+  const logError = options.logError ?? ((message) => console.error(message));
+  const queueLimit = options.queueLimit ?? QUEUE_LIMIT;
+  const hider = createSecretHider({ env: options.env, secrets: options.secrets });
+  const pending = /* @__PURE__ */ new Set();
+  let waiting = 0;
+  let turn = Promise.resolve();
+  let closed = false;
+  const deletedChats = /* @__PURE__ */ new Set();
+  function serial(operation) {
+    const result = turn.then(operation, operation);
+    turn = result.catch(() => {
+    });
+    return result;
+  }
+  function enqueue(kind, save) {
+    if (closed) return;
+    if (waiting >= queueLimit) {
+      logError(`\u0436\u0443\u0440\u043D\u0430\u043B \u043F\u0435\u0441\u043E\u0447\u043D\u0438\u0446\u044B: \u043E\u0447\u0435\u0440\u0435\u0434\u044C \u0437\u0430\u043F\u0438\u0441\u0438 \u043F\u0435\u0440\u0435\u043F\u043E\u043B\u043D\u0435\u043D\u0430 (${queueLimit}), ${kind} \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D\u043E`);
+      return;
+    }
+    waiting += 1;
+    const task = new Promise((resolve) => setImmediate(resolve)).then(() => serial(save)).catch((error) => logError(`\u0436\u0443\u0440\u043D\u0430\u043B \u043F\u0435\u0441\u043E\u0447\u043D\u0438\u0446\u044B: \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D\u043E ${kind}: ${errorMessage(error)}`)).finally(() => {
+      waiting -= 1;
+      pending.delete(task);
+    });
+    pending.add(task);
+  }
+  async function flush() {
+    while (pending.size > 0) await Promise.all([...pending]);
+  }
+  async function entriesOf(chatId) {
+    const [models, tools] = await Promise.all([store.listModelCalls(chatId), store.listToolCalls(chatId)]);
+    models.sort(byTime);
+    tools.sort(byTime);
+    return { models, tools, changed: changedInstructions(models) };
+  }
+  async function blobMap(hashes) {
+    const rows = await store.loadBlobs([...new Set(hashes)]);
+    const blobs = await Promise.all(rows.map(unpackBlob));
+    return new Map(blobs.map((blob) => [blob.hash, blob]));
+  }
+  return {
+    addSecrets: (values) => hider.addSecrets(values),
+    enqueueModelCall(event) {
+      if (deletedChats.has(event.chatId)) return;
+      enqueue("\u043E\u0431\u0440\u0430\u0449\u0435\u043D\u0438\u0435 \u043A \u043C\u043E\u0434\u0435\u043B\u0438", async () => {
+        const { row, blobs } = await splitModelCall(event, hider.forSettings(event.request.settings));
+        await store.saveModelCall(row, blobs);
+      });
+    },
+    enqueueToolCall(event) {
+      if (deletedChats.has(event.chatId)) return;
+      enqueue("\u0432\u044B\u0437\u043E\u0432 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0430", async () => {
+        const { row, blobs } = await splitToolCall(event, hider.forSettings(void 0));
+        await store.saveToolCall(row, blobs);
+      });
+    },
+    flush,
+    async listForChat(chatId, listOptions) {
+      await flush();
+      const { models, tools, changed } = await entriesOf(chatId);
+      const entries = [
+        ...models.map((row) => modelSummary(row, changed.has(row.id))),
+        ...tools.map((row) => toolRecord(row, linkedModelCall(row, models)))
+      ].sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime() || (a.kind === b.kind ? 0 : a.kind === "model" ? -1 : 1));
+      const messageId = listOptions?.messageId;
+      return messageId === void 0 ? entries : entries.filter((entry) => entry.messageId === messageId);
+    },
+    async getCall(callId) {
+      await flush();
+      const model = await store.findModelCall(callId);
+      if (model) {
+        const { changed } = await entriesOf(model.chatId);
+        const blobs2 = await blobMap([model.instructionsHash, ...model.messageHashes, model.toolsHash, model.settingsHash, model.responseHash]);
+        const blob2 = (hash) => blobs2.get(hash) ?? { hash, content: MISSING_BLOB, bytes: 0, truncated: false };
+        const call = {
+          ...modelSummary(model, changed.has(model.id)),
+          instructionsHash: model.instructionsHash,
+          messageHashes: model.messageHashes,
+          toolsHash: model.toolsHash,
+          settingsHash: model.settingsHash,
+          responseHash: model.responseHash
+        };
+        return {
+          kind: "model",
+          call,
+          instructions: blob2(model.instructionsHash),
+          messages: model.messageHashes.map(blob2),
+          tools: blob2(model.toolsHash),
+          settings: blob2(model.settingsHash),
+          response: blob2(model.responseHash)
+        };
+      }
+      const tool = await store.findToolCall(callId);
+      if (!tool) return null;
+      const siblings = await store.listModelCalls(tool.chatId);
+      const blobs = await blobMap(tool.outputHash ? [tool.inputHash, tool.outputHash] : [tool.inputHash]);
+      const blob = (hash) => blobs.get(hash) ?? { hash, content: MISSING_BLOB, bytes: 0, truncated: false };
+      return { kind: "tool", call: toolRecord(tool, linkedModelCall(tool, siblings)), input: blob(tool.inputHash), output: tool.outputHash ? blob(tool.outputHash) : null };
+    },
+    async getBlob(hash, ownerId) {
+      await flush();
+      const row = await store.loadBlobForOwner(hash, ownerId);
+      return row ? unpackBlob(row) : null;
+    },
+    getSettings: (chatId) => store.getSettings(chatId),
+    setSettings: (settings) => serial(() => store.setSettings(settings)),
+    markAnswerEdited: (record) => serial(() => store.saveAnswerEdit(record)),
+    listEditedAnswers: (chatId) => store.listAnswerEdits(chatId),
+    async deleteChat(chatId) {
+      if (deletedChats.size >= DELETED_CHATS_LIMIT) deletedChats.delete(deletedChats.values().next().value);
+      deletedChats.add(chatId);
+      await flush();
+      await serial(() => store.deleteChat(chatId));
+    },
+    async deleteOlderThan(before) {
+      await flush();
+      return serial(() => store.deleteOlderThan(before));
+    },
+    async close() {
+      if (closed) return;
+      await flush();
+      closed = true;
+      await turn;
+      await store.close();
+    }
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function byTime(a, b) {
+  return a.startedAt.getTime() - b.startedAt.getTime() || (a.attempt ?? 0) - (b.attempt ?? 0);
+}
+function changedInstructions(sortedModels) {
+  const lastByPurpose = /* @__PURE__ */ new Map();
+  const changed = /* @__PURE__ */ new Set();
+  for (const row of sortedModels) {
+    const previous = lastByPurpose.get(row.purpose);
+    if (previous !== void 0 && previous !== row.instructionsHash) changed.add(row.id);
+    lastByPurpose.set(row.purpose, row.instructionsHash);
+  }
+  return changed;
+}
+function linkedModelCall(tool, models) {
+  const candidates = models.filter((model) => model.chatId === tool.chatId && model.toolCallIds.includes(tool.toolCallId));
+  if (candidates.length === 0) return null;
+  const sameTurn = candidates.filter((model) => model.messageId === tool.messageId);
+  const pool = sameTurn.length > 0 ? sameTurn : candidates;
+  const before = pool.filter((model) => model.startedAt.getTime() <= tool.startedAt.getTime()).sort(byTime);
+  return (before.at(-1) ?? pool.sort(byTime)[0])?.id ?? null;
+}
+function modelSummary(row, instructionsChanged) {
+  return {
+    kind: "model",
+    id: row.id,
+    chatId: row.chatId,
+    ownerId: row.ownerId,
+    messageId: row.messageId,
+    purpose: row.purpose,
+    attempt: row.attempt,
+    modelId: row.modelId,
+    providerId: row.providerId,
+    usage: row.usage,
+    costUsd: row.costUsd,
+    startedAt: row.startedAt,
+    firstChunkMs: row.firstChunkMs,
+    durationMs: row.durationMs,
+    status: row.status,
+    error: row.error,
+    instructionsChanged
+  };
+}
+function toolRecord(row, modelCallId) {
+  return {
+    kind: "tool",
+    id: row.id,
+    chatId: row.chatId,
+    ownerId: row.ownerId,
+    messageId: row.messageId,
+    modelCallId,
+    toolCallId: row.toolCallId,
+    toolName: row.toolName,
+    inputHash: row.inputHash,
+    outputHash: row.outputHash,
+    error: row.error,
+    startedAt: row.startedAt,
+    durationMs: row.durationMs
+  };
+}
+
+export {
+  secretsFromEnv,
+  createSandboxJournal
+};
+//# sourceMappingURL=chunk-4O5NPJOS.js.map