@ykurilov/agent-chat-server 0.0.0-stage → 0.56.0

package/dist/index.js

@@ -0,0 +1,732 @@
+// src/chat-handler.ts
+import {
+  ApprovalNotPendingError,
+  AttachmentRejectedError,
+  BrowserCallNotPendingError,
+  ChatBusyError,
+  ChatNotFoundError,
+  createChatEvents,
+  accessRefusedResponse,
+  allowedUser,
+  createChatService,
+  hiddenStateKeyOf,
+  createRunningAnswerRegistry,
+  DuplicateMessageError,
+  InvalidChatTitleError,
+  InvalidMessageError,
+  InvalidModelChoiceError,
+  isScreenPlaceInput,
+  isTabId,
+  isVoiceSound,
+  NothingToRetryError,
+  createRequestOriginCheck,
+  originRefusalHint,
+  isSafeMethod,
+  SpendingLimitReachedError,
+  TooManyTurnsError,
+  TurnRefusedError,
+  ActionForbiddenError,
+  ChatClosedError,
+  ChatCreationRefusedError,
+  turnOriginOf,
+  InvalidWidgetAnswerError,
+  WidgetAnswerCheckAbortedError,
+  WidgetAnswerCheckTimeoutError,
+  WidgetAnswerRefusedError,
+  WidgetNotPendingError
+} from "@ykurilov/agent-chat-core";
+
+// src/heartbeat.ts
+import { JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS } from "ai";
+var HEARTBEAT_HEADER = "x-agent-chat-heartbeat-ms";
+var MIN_HEARTBEAT_INTERVAL_MS = 1e3;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
+var PING = new TextEncoder().encode(": ping\n\n");
+function createHeartbeatResponse(options) {
+  const { stream, heartbeatIntervalMs } = options;
+  assertHeartbeatInterval(heartbeatIntervalMs);
+  const events = stream.pipeThrough(new JsonToSseTransformStream()).getReader();
+  const encoder = new TextEncoder();
+  let timer;
+  let cancelled = false;
+  const stopTimer = () => {
+    if (timer !== void 0) clearInterval(timer);
+    timer = void 0;
+  };
+  const body = new ReadableStream({
+    start(controller) {
+      controller.enqueue(PING);
+      timer = setInterval(() => controller.enqueue(PING), heartbeatIntervalMs);
+    },
+    async pull(controller) {
+      try {
+        const { done, value } = await events.read();
+        if (cancelled) return;
+        if (done) {
+          stopTimer();
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(value));
+      } catch (error) {
+        stopTimer();
+        throw error;
+      }
+    },
+    cancel(reason) {
+      cancelled = true;
+      stopTimer();
+      return events.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    headers: { ...UI_MESSAGE_STREAM_HEADERS, [HEARTBEAT_HEADER]: String(heartbeatIntervalMs) }
+  });
+}
+function assertHeartbeatInterval(heartbeatIntervalMs) {
+  if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs < MIN_HEARTBEAT_INTERVAL_MS) {
+    throw new RangeError(
+      `heartbeatIntervalMs \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${MIN_HEARTBEAT_INTERVAL_MS} \u043C\u0441, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${heartbeatIntervalMs}`
+    );
+  }
+}
+
+// src/request-body.ts
+var MAX_JSON_BODY_BYTES = 1024 * 1024;
+var RequestBodyTooLargeError = class extends Error {
+  constructor(maxBytes) {
+    super(`\u0422\u0435\u043B\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u0431\u043E\u043B\u044C\u0448\u0435 ${maxBytes} \u0431\u0430\u0439\u0442`);
+    this.name = "RequestBodyTooLargeError";
+  }
+};
+async function readJsonBody(request, maxBytes = MAX_JSON_BODY_BYTES) {
+  if (Number(request.headers.get("content-length")) > maxBytes) throw new RequestBodyTooLargeError(maxBytes);
+  if (!request.body) return null;
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (let read = await reader.read(); !read.done; read = await reader.read()) {
+      size += read.value.byteLength;
+      if (size > maxBytes) {
+        void reader.cancel().catch(() => void 0);
+        throw new RequestBodyTooLargeError(maxBytes);
+      }
+      chunks.push(read.value);
+    }
+  } catch (error) {
+    if (error instanceof RequestBodyTooLargeError) throw error;
+    return null;
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  }
+}
+
+// src/memory-routes.ts
+var statusOfKind = {
+  invalid: 400,
+  not_found: 404,
+  stale_version: 409,
+  duplicate: 409,
+  limit_reached: 409
+};
+var errorResponse = (kind) => Response.json({ error: { kind } }, { status: statusOfKind[kind] });
+function publicNote({ id, categories, content, version, createdAt, updatedAt }) {
+  return { id, categories, content, version, createdAt, updatedAt };
+}
+function publicMerge({ runId, finishedAt, revertible, groups }) {
+  return {
+    runId,
+    finishedAt,
+    revertible,
+    groups: groups.map(({ result, originals }) => ({ result: publicNote(result), originals: originals.map(publicNote) }))
+  };
+}
+var isVersion = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1;
+async function readBody(request) {
+  const body = await readJsonBody(request);
+  return typeof body === "object" && body !== null && !Array.isArray(body) ? body : null;
+}
+var noteFrom = (body) => ({ categories: body?.categories, content: body?.content });
+async function handleMemoryRequest(input) {
+  const { memory, request, userId, segments } = input;
+  const method = request.method.toUpperCase();
+  const [id, ...rest] = segments;
+  if (id === "merges") return handleMergesRequest({ memory, method, userId, rest });
+  if (rest.length > 0) return errorResponse("not_found");
+  if (id === void 0) {
+    if (method === "GET") return Response.json(await listForScreen(memory, userId));
+    if (method === "POST") {
+      const created = await memory.create(userId, noteFrom(await readBody(request)));
+      return created.ok ? Response.json({ note: publicNote(created.value) }, { status: 201 }) : errorResponse(created.error.kind);
+    }
+    if (method === "DELETE") return Response.json({ deleted: await memory.clear(userId) });
+    return errorResponse("not_found");
+  }
+  if (method === "PATCH") {
+    const body = await readBody(request);
+    if (!isVersion(body?.version)) return errorResponse("invalid");
+    const updated = await memory.update(userId, id, body.version, noteFrom(body));
+    return updated.ok ? Response.json({ note: publicNote(updated.value) }) : errorResponse(updated.error.kind);
+  }
+  if (method === "DELETE") {
+    const version = Number(new URL(request.url).searchParams.get("version") || Number.NaN);
+    if (!isVersion(version)) return errorResponse("invalid");
+    const removed = await memory.remove(userId, id, version);
+    return removed.ok ? new Response(null, { status: 204 }) : errorResponse(removed.error.kind);
+  }
+  return errorResponse("not_found");
+}
+async function handleMergesRequest(input) {
+  const { memory, method, userId, rest } = input;
+  const { listMerges, revertMerge } = memory;
+  if (typeof listMerges !== "function" || typeof revertMerge !== "function") return errorResponse("not_found");
+  if (rest.length === 0 && method === "GET") {
+    const merges = await listMerges.call(memory, userId);
+    return Response.json({ merges: merges.map(publicMerge) });
+  }
+  const [runId, action, ...extra] = rest;
+  if (runId !== void 0 && action === "revert" && extra.length === 0 && method === "POST") {
+    const result = await revertMerge.call(memory, userId, runId);
+    if (result === "ok") return Response.json({ reverted: runId });
+    return result === "not_found" ? errorResponse("not_found") : Response.json({ error: { kind: result } }, { status: 409 });
+  }
+  return errorResponse("not_found");
+}
+async function listForScreen(memory, userId) {
+  const { notes, counts } = await memory.list(userId);
+  return { notes: notes.map(publicNote), counts: { total: counts.total, limit: counts.limit, shown: counts.shown } };
+}
+
+// src/subject-chat-route.ts
+import { normalizeTurnRefusal, SUBJECT_KEY_MAX_LENGTH } from "@ykurilov/agent-chat-core";
+function turnRefusalResponse(refusal) {
+  const { code, message } = normalizeTurnRefusal(refusal);
+  return Response.json({ error: { kind: "turn_refused", code, message } }, { status: 403 });
+}
+async function openSubjectChatRoute(input) {
+  const key = (await readJsonBody(input.request))?.key;
+  if (typeof key !== "string" || key.length === 0 || key.length > SUBJECT_KEY_MAX_LENGTH) return input.invalid();
+  const settings = await input.resolve({ user: { id: input.userId }, key, request: input.request });
+  if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+    throw new TypeError(`subjectChats \u0434\u043E\u043B\u0436\u0435\u043D \u0432\u0435\u0440\u043D\u0443\u0442\u044C \u043E\u0431\u044A\u0435\u043A\u0442 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043A \u0438\u043B\u0438 \u043E\u0442\u043A\u0430\u0437 { code, message }, \u0430 \u0432\u0435\u0440\u043D\u0443\u043B ${settings === null ? "null" : Array.isArray(settings) ? "\u043C\u0430\u0441\u0441\u0438\u0432" : typeof settings}.`);
+  }
+  if ("code" in settings) return turnRefusalResponse(settings);
+  const { chat, created } = await input.service.openSubjectChat({ ownerId: input.userId, key, ...settings });
+  return Response.json({ id: chat.id, created });
+}
+
+// src/new-chat-data.ts
+async function resolveNewChatData(resolve, input) {
+  const data = await resolve(input);
+  if (data === void 0) return void 0;
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new TypeError(`newChatData \u0434\u043E\u043B\u0436\u0435\u043D \u0432\u0435\u0440\u043D\u0443\u0442\u044C \u043E\u0431\u044A\u0435\u043A\u0442 \u0434\u0430\u043D\u043D\u044B\u0445 \u0447\u0430\u0442\u0430 \u0438\u043B\u0438 undefined, \u0430 \u0432\u0435\u0440\u043D\u0443\u043B ${data === null ? "null" : Array.isArray(data) ? "\u043C\u0430\u0441\u0441\u0438\u0432" : typeof data}.`);
+  }
+  return data;
+}
+
+// src/watch-stream.ts
+import { publicAppState } from "@ykurilov/agent-chat-core";
+var WATCH_RECONCILE_EVERY_MS = 5e3;
+var LIVE_TASK_STATUSES = /* @__PURE__ */ new Set(["queued", "running", "awaiting_approval"]);
+function createWatchStream(options) {
+  const { ownerId, chatId, listTasks } = options;
+  let closed = false;
+  let timer;
+  let unsubscribe;
+  let lastTasks;
+  const announced = /* @__PURE__ */ new Set();
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    clearTimeout(timer);
+    unsubscribe?.();
+    options.signal?.removeEventListener("abort", onClientGone);
+    options.onClose();
+  };
+  let onClientGone = () => close();
+  return new ReadableStream({
+    start(controller) {
+      onClientGone = () => {
+        const wasOpen = !closed;
+        close();
+        if (wasOpen) controller.close();
+      };
+      const send = (event) => {
+        if (!closed) controller.enqueue(event);
+      };
+      const checkTasks = async () => {
+        const tasks = await listTasks();
+        const snapshot = JSON.stringify(tasks);
+        if (lastTasks !== void 0 && snapshot !== lastTasks) send({ type: "tasks-changed", chatId });
+        lastTasks = snapshot;
+        return tasks.some((task) => LIVE_TASK_STATUSES.has(task.status));
+      };
+      const tick = async () => {
+        timer = void 0;
+        try {
+          const live = await checkTasks();
+          const turn = await options.detachedTurn();
+          if (turn && !announced.has(turn.messageId)) {
+            announced.add(turn.messageId);
+            send({ type: "turn-started", chatId, ...turn });
+          }
+          if (live) scheduleReconcile();
+        } catch (error) {
+          options.logError(`\u041D\u0430\u0431\u043B\u044E\u0434\u0435\u043D\u0438\u0435 \u0437\u0430 \u0447\u0430\u0442\u043E\u043C ${chatId}: \u0441\u0432\u0435\u0440\u043A\u0430 \u0441 \u0431\u0430\u0437\u043E\u0439 \u043D\u0435 \u0443\u0434\u0430\u043B\u0430\u0441\u044C: ${error instanceof Error ? error.message : String(error)}`);
+          scheduleReconcile();
+        }
+      };
+      const scheduleReconcile = () => {
+        if (closed || timer !== void 0 || !listTasks) return;
+        timer = setTimeout(() => void tick(), WATCH_RECONCILE_EVERY_MS);
+      };
+      unsubscribe = options.subscribeEvents((event) => {
+        if (event.ownerId !== ownerId || event.chatId !== chatId) return;
+        if (event.type === "chat-data-changed") return;
+        const { ownerId: _, ...forTab } = event;
+        if (event.type === "turn-started") announced.add(event.messageId);
+        send(forTab.type === "state-changed" && options.hiddenStateKey ? { ...forTab, state: publicAppState(forTab.state, options.hiddenStateKey) } : forTab);
+        if (event.type === "tasks-changed") scheduleReconcile();
+      });
+      if (options.signal?.aborted) {
+        onClientGone();
+        return;
+      }
+      options.signal?.addEventListener("abort", onClientGone, { once: true });
+      if (listTasks) {
+        void checkTasks().then((live) => {
+          if (live) scheduleReconcile();
+        }).catch((error) => {
+          options.logError(`\u041D\u0430\u0431\u043B\u044E\u0434\u0435\u043D\u0438\u0435 \u0437\u0430 \u0447\u0430\u0442\u043E\u043C ${chatId}: \u0437\u0430\u0434\u0430\u0447\u0438 \u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D\u044B: ${error instanceof Error ? error.message : String(error)}`);
+          scheduleReconcile();
+        });
+      }
+    },
+    cancel() {
+      close();
+    }
+  });
+}
+
+// src/chat-handler.ts
+var logValue = (value) => /[\p{Cc}\u2028\u2029]/u.test(value) ? JSON.stringify(value) : value;
+function createChatHandler(options) {
+  return createChatServer(options).handler;
+}
+function createChatServer(options) {
+  const basePath = options.basePath.replace(/\/+$/, "");
+  const heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+  assertHeartbeatInterval(heartbeatIntervalMs);
+  const streamResponse = (stream) => createHeartbeatResponse({ stream, heartbeatIntervalMs });
+  const logError = options.logError ?? ((message) => console.error(message));
+  const allowsOrigin = createRequestOriginCheck({
+    allowedOrigins: options.allowedOrigins,
+    onRefused: (refusal) => logError(`\u0427\u0430\u0442: ${originRefusalHint(refusal)}`)
+  });
+  if (options.newChatData && !options.storage.updateChatData) {
+    throw new Error("newChatData \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0441 updateChatData: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0435\u0433\u043E \u043D\u0435 \u0443\u043C\u0435\u0435\u0442.");
+  }
+  if (options.subjectChats && !options.storage.findChatBySubject) {
+    throw new Error("subjectChats \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 \u0441 findChatBySubject: \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0435\u0433\u043E \u043D\u0435 \u0443\u043C\u0435\u0435\u0442.");
+  }
+  const service = createChatService({
+    storage: options.storage,
+    catalog: options.catalog,
+    registry: createRunningAnswerRegistry(),
+    ...options.defaultChoice && { defaultChoice: options.defaultChoice },
+    agent: options.agent,
+    ...options.compaction !== void 0 && { compaction: options.compaction },
+    ...options.attachments && { attachments: options.attachments },
+    ...options.limits && { limits: options.limits },
+    ...options.maxConcurrentTurnsPerUser !== void 0 && { maxConcurrentTurnsPerUser: options.maxConcurrentTurnsPerUser },
+    ...options.beforeTurn && { beforeTurn: options.beforeTurn },
+    ...options.turnNotStarted && { turnNotStarted: options.turnNotStarted },
+    ...options.chatCapabilities && { chatCapabilities: options.chatCapabilities },
+    ...options.beforeCreateChat && { beforeCreateChat: options.beforeCreateChat },
+    ...options.memory && { memory: options.memory },
+    ...options.env && { env: options.env },
+    logError,
+    ...options.turnObserver && { turnObserver: options.turnObserver },
+    ...options.chatInstructions && { chatInstructions: options.chatInstructions },
+    ...options.staffOfChat && { staffOfChat: options.staffOfChat },
+    ...options.lockedToolOutputs && { lockedToolOutputs: options.lockedToolOutputs },
+    chatEvents: createChatEvents((error) => logError(`\u0421\u043E\u0431\u044B\u0442\u0438\u044F \u0447\u0430\u0442\u0430: \u0441\u0431\u043E\u0439 \u0441\u043B\u0443\u0448\u0430\u0442\u0435\u043B\u044F: ${describe(error)}`)),
+    ...options.background && { background: options.background },
+    ...options.onTurnFinished && { onTurnFinished: options.onTurnFinished },
+    ...options.afterTurn && { afterTurn: options.afterTurn },
+    ...options.afterTurnTimeoutMs !== void 0 && { afterTurnTimeoutMs: options.afterTurnTimeoutMs },
+    ...options.afterTurnAttempts !== void 0 && { afterTurnAttempts: options.afterTurnAttempts },
+    ...options.onStateChanged && { onStateChanged: options.onStateChanged },
+    ...options.onStateChangedTimeoutMs !== void 0 && { onStateChangedTimeoutMs: options.onStateChangedTimeoutMs },
+    ...options.onStateChangedAttempts !== void 0 && { onStateChangedAttempts: options.onStateChangedAttempts },
+    ...options.onModelChosen && { onModelChosen: options.onModelChosen },
+    ...options.modelMenu && { modelMenu: options.modelMenu },
+    ...options.privateStateKeys && { privateStateKeys: options.privateStateKeys },
+    ...options.replyChecks && { replyChecks: options.replyChecks },
+    ...options.now && { now: options.now }
+  });
+  const hiddenStateKey = hiddenStateKeyOf(options.privateStateKeys);
+  const background = options.background;
+  async function answerTaskApproval(ownerId, chatId, taskId, approvalId, decision) {
+    await service.assertTurnAllowed(ownerId, chatId, "approval");
+    return background.answerApproval(ownerId, chatId, taskId, approvalId, decision);
+  }
+  const watchers = /* @__PURE__ */ new Map();
+  const watcherKey = (ownerId, chatId) => JSON.stringify([ownerId, chatId]);
+  const hasWatchers = (ownerId, chatId) => (watchers.get(watcherKey(ownerId, chatId)) ?? 0) > 0;
+  function watchResponse(request, userId, chatId) {
+    const key = watcherKey(userId, chatId);
+    watchers.set(key, (watchers.get(key) ?? 0) + 1);
+    let counted = true;
+    const uncount = () => {
+      if (!counted) return;
+      counted = false;
+      const left = (watchers.get(key) ?? 1) - 1;
+      if (left > 0) watchers.set(key, left);
+      else watchers.delete(key);
+    };
+    try {
+      const stream = createWatchStream({
+        ownerId: userId,
+        chatId,
+        signal: request.signal,
+        subscribeEvents: (listener) => service.subscribeEvents(listener),
+        hiddenStateKey,
+        ...background && { listTasks: () => background.listForChat(userId, chatId) },
+        async detachedTurn() {
+          const history = await service.getHistory(userId, chatId);
+          const answer = history.messages.at(-1);
+          return history.detachedAnswer && answer ? { messageId: answer.id, ...turnOriginOf(history.messages) } : null;
+        },
+        onClose: uncount,
+        logError
+      });
+      return streamResponse(stream);
+    } catch (error) {
+      uncount();
+      throw error;
+    }
+  }
+  async function route(request, userId, segments) {
+    const [chatId, action, ...rest] = segments;
+    const method = request.method.toUpperCase();
+    if (options.attachments) {
+      if (chatId === "attachments" && action === "settings" && rest.length === 0 && method === "GET") {
+        return options.attachments.settings();
+      }
+      if (chatId !== void 0 && action === "attachments") {
+        await service.assertOwnChat(userId, chatId);
+        if (method !== "GET" && method !== "HEAD") await service.assertCapability(userId, chatId, "attachments");
+        return options.attachments.handle({ request, userId, chatId, segments: rest });
+      }
+    }
+    if (options.memory && chatId === "memory") {
+      return handleMemoryRequest({ memory: options.memory, request, userId, segments: segments.slice(1) });
+    }
+    if (chatId !== void 0 && action === "approvals" && rest.length === 1 && method === "POST") {
+      const body = await readJsonBody(request);
+      const decision = body?.decision;
+      if (decision !== "allow" && decision !== "deny" && decision !== "always") return errorResponse2(400, "invalid");
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      return Response.json(await service.answerApproval(userId, chatId, rest[0], decision, page));
+    }
+    if (chatId !== void 0 && action === "widgets" && rest.length === 1 && method === "POST") {
+      const toolCallId = rest[0];
+      const body = await readWidgetAnswerBody(request);
+      if (!body) {
+        logError(`[\u0432\u0438\u0434\u0436\u0435\u0442] \u043E\u0442\u043A\u0430\u0437 invalid_answer \u0447\u0430\u0442=${logValue(chatId)} \u0432\u044B\u0437\u043E\u0432=${logValue(toolCallId)}`);
+        return errorResponse2(400, "invalid_answer");
+      }
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      return Response.json(await service.answerWidget({ chatId, ownerId: userId, toolCallId, answer: body.answer, ...page && { page } }));
+    }
+    if (chatId !== void 0 && action === "browser-tools" && rest.length === 1 && method === "POST") {
+      const answer = parseBrowserCallAnswer(await readJsonBody(request, MAX_BROWSER_CALL_BODY_BYTES));
+      if (!answer) return errorResponse2(400, "invalid");
+      await service.answerBrowserCall(userId, chatId, rest[0], answer);
+      return new Response(null, { status: 204 });
+    }
+    if (chatId !== void 0 && action === "watch" && rest.length === 0 && method === "GET") {
+      await service.assertOwnChat(userId, chatId);
+      return watchResponse(request, userId, chatId);
+    }
+    if (background && chatId !== void 0 && action === "tasks") {
+      const [taskId, taskAction, ...extra] = rest;
+      if (taskId === void 0 && method === "GET") {
+        await service.assertOwnChat(userId, chatId);
+        return Response.json(await background.listForChat(userId, chatId));
+      }
+      if (taskId !== void 0 && taskAction === "cancel" && extra.length === 0 && method === "POST") {
+        await service.assertOwnChat(userId, chatId);
+        const status = await background.cancel(userId, chatId, taskId);
+        return status === "not_found" ? errorResponse2(404, "not_found") : Response.json({ status });
+      }
+      if (taskId !== void 0 && taskAction === "approval" && extra.length === 0 && method === "POST") {
+        await service.assertOwnChat(userId, chatId);
+        const body = await readJsonBody(request);
+        const decision = body?.decision;
+        const approvalId = body?.approvalId;
+        if (decision !== "allow" && decision !== "deny" || typeof approvalId !== "string" || approvalId === "") return errorResponse2(400, "invalid");
+        const status = await answerTaskApproval(userId, chatId, taskId, approvalId, decision);
+        if (status === "not_found") return errorResponse2(409, "approval_not_pending");
+        if (status === "stale") return errorResponse2(409, "approval_stale");
+        return Response.json({ status });
+      }
+    }
+    if (rest.length > 0) return errorResponse2(404, "not_found");
+    if (options.subjectChats && chatId === "subject" && action === void 0 && method === "POST") {
+      return openSubjectChatRoute({ request, userId, service, resolve: options.subjectChats, invalid: () => errorResponse2(400, "invalid") });
+    }
+    if (chatId === void 0) {
+      if (method === "GET" && options.chatList) return Response.json({ chats: await service.listChats(userId, chatListOptions(options.chatList)) });
+      if (method !== "POST") return errorResponse2(404, "not_found");
+      const data = options.newChatData ? await resolveNewChatData(options.newChatData, { user: { id: userId }, request }) : void 0;
+      const chat = await service.createChat(userId, data && { data });
+      return Response.json({ id: chat.id }, { status: 201 });
+    }
+    if (chatId === "models" && action === void 0 && method === "GET") {
+      return Response.json(await service.getModelMenu(userId));
+    }
+    if (action === void 0 && method === "GET") {
+      return Response.json({ ...await service.getHistory(userId, chatId), backgroundTasks: background !== void 0 });
+    }
+    if (action === void 0 && method === "PATCH" && options.chatList) {
+      const title = (await readJsonBody(request))?.title;
+      if (typeof title !== "string") return errorResponse2(400, "invalid");
+      return Response.json({ id: chatId, title: await service.renameChat(userId, chatId, title) });
+    }
+    if (action === void 0 && method === "DELETE" && options.chatList) {
+      await service.deleteChat(userId, chatId);
+      return new Response(null, { status: 204 });
+    }
+    if (action === "compactions" && method === "GET") {
+      return Response.json(await service.getCompactions(userId, chatId));
+    }
+    if (action === "spending" && method === "GET" && options.limits) {
+      return Response.json(await service.getSpendingStatus(userId, chatId));
+    }
+    if (action === "branches" && method === "GET") {
+      return Response.json(await service.getBranchForks(userId, chatId));
+    }
+    if (action === "branch" && method === "POST") {
+      const messageId = parseMessageId(await readJsonBody(request));
+      if (!messageId) return errorResponse2(400, "invalid");
+      return Response.json(await service.selectBranch(userId, chatId, messageId));
+    }
+    if (action === "regenerate" && method === "POST") {
+      const body = await readJsonBody(request);
+      const messageId = parseMessageId(body);
+      if (!messageId) return errorResponse2(400, "invalid");
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      return streamResponse(await service.regenerate(userId, chatId, messageId, page));
+    }
+    if (action === "edit" && method === "POST") {
+      const body = await readJsonBody(request);
+      const { editedMessageId, message } = body ?? {};
+      if (typeof editedMessageId !== "string" || !message || typeof message !== "object") return errorResponse2(400, "invalid");
+      if (body?.voiceMode !== void 0 && typeof body.voiceMode !== "boolean") return errorResponse2(400, "invalid");
+      const voiceSounds = parseVoiceSounds(body?.voiceSounds);
+      if (voiceSounds === "invalid") return errorResponse2(400, "invalid");
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      return streamResponse(
+        await service.editMessage(userId, chatId, editedMessageId, message, { voiceMode: body?.voiceMode === true, voiceSounds, ...page && { page } })
+      );
+    }
+    if (action === "model" && method === "PUT") {
+      const choice = parseModelChoice(await readJsonBody(request));
+      if (!choice) return errorResponse2(400, "invalid");
+      return Response.json(await service.setModel(userId, chatId, choice));
+    }
+    if (action === "messages" && method === "POST") {
+      const body = await readJsonBody(request);
+      const message = body?.message;
+      if (!message || typeof message !== "object") return errorResponse2(400, "invalid");
+      if (body.voiceMode !== void 0 && typeof body.voiceMode !== "boolean") return errorResponse2(400, "invalid");
+      const voiceSounds = parseVoiceSounds(body.voiceSounds);
+      if (voiceSounds === "invalid") return errorResponse2(400, "invalid");
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      const stream = await service.sendMessage(userId, chatId, message, { voiceMode: body.voiceMode === true, voiceSounds, ...page && { page } });
+      return streamResponse(stream);
+    }
+    if (action === "steer" && method === "POST") {
+      const body = await readJsonBody(request);
+      const message = body?.message;
+      if (!message || typeof message !== "object") return errorResponse2(400, "invalid");
+      const page = parsePage(body);
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      return Response.json(await service.steer(userId, chatId, message, page && { page }), { status: 202 });
+    }
+    if (action === "retry" && method === "POST") {
+      const page = parsePage(await readJsonBody(request));
+      if (page === "invalid") return errorResponse2(400, "invalid");
+      const stream = await service.retry(userId, chatId, page);
+      return streamResponse(stream);
+    }
+    if (action === "stream" && method === "GET") {
+      const stream = await service.subscribe(userId, chatId);
+      if (!stream) return new Response(null, { status: 204 });
+      return streamResponse(stream);
+    }
+    if (action === "stop" && method === "POST") {
+      const stopped = await service.stop(userId, chatId);
+      return new Response(null, { status: stopped ? 202 : 204 });
+    }
+    return errorResponse2(404, "not_found");
+  }
+  const handler = {
+    basePath,
+    recoverInterruptedAnswers: (recoverOptions) => service.recoverInterruptedAnswers(recoverOptions),
+    flush: (flushOptions) => service.flush(flushOptions),
+    hasWatchers,
+    async fetch(request) {
+      const segments = pathSegments(new URL(request.url).pathname, basePath);
+      if (!segments) return errorResponse2(404, "not_found");
+      if (!isSafeMethod(request.method) && !allowsOrigin(request)) return errorResponse2(403, "forbidden_origin");
+      try {
+        const resolved = await options.resolveUser(request);
+        const refused = accessRefusedResponse(resolved);
+        if (refused) return refused;
+        const user = allowedUser(resolved);
+        if (!user) return errorResponse2(401, "invalid");
+        return await route(request, user.id, segments);
+      } catch (error) {
+        const response = errorToResponse(error);
+        if (response.status >= 500) logError(`\u0427\u0430\u0442: \u0441\u0431\u043E\u0439 \u043D\u0430 ${request.method} ${new URL(request.url).pathname}: ${describe(error)}`);
+        return response;
+      }
+    }
+  };
+  const serverService = Object.assign(service, {
+    hasWatchers,
+    ...background && { tasks: { list: background.listForChat.bind(background), cancel: background.cancel.bind(background), answerApproval: answerTaskApproval } }
+  });
+  return { handler, service: serverService };
+}
+function pathSegments(pathname, basePath) {
+  if (pathname !== basePath && !pathname.startsWith(`${basePath}/`)) return null;
+  try {
+    return pathname.slice(basePath.length).split("/").filter((segment) => segment.length > 0).map((segment) => decodeURIComponent(segment));
+  } catch {
+    return null;
+  }
+}
+function parseVoiceSounds(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.every(isVoiceSound)) return "invalid";
+  return value;
+}
+function parsePage(body) {
+  const { place, tabId, timeZone } = typeof body === "object" && body !== null ? body : {};
+  const zone = typeof timeZone === "string" ? timeZone : void 0;
+  if (place === void 0 && tabId === void 0 && zone === void 0) return void 0;
+  if (place !== void 0 && !isScreenPlaceInput(place)) return "invalid";
+  if (tabId !== void 0 && !isTabId(tabId)) return "invalid";
+  return { ...place !== void 0 && { place }, ...tabId !== void 0 && { tabId }, ...zone !== void 0 && { timeZone: zone } };
+}
+function parseBrowserCallAnswer(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const { tabId } = body;
+  if (!isTabId(tabId)) return null;
+  const hasOutput = Object.hasOwn(body, "output");
+  const hasError = Object.hasOwn(body, "error");
+  if (hasOutput === hasError) return null;
+  if (hasOutput) return { tabId, output: body.output };
+  const { error } = body;
+  return typeof error === "string" ? { tabId, error } : null;
+}
+function parseMessageId(body) {
+  const { messageId } = body ?? {};
+  return typeof messageId === "string" && messageId.length > 0 ? messageId : null;
+}
+function parseModelChoice(body) {
+  const { modelId, providerId, reasoning } = body ?? {};
+  if (typeof modelId !== "string" || typeof providerId !== "string") return null;
+  if (reasoning !== void 0 && typeof reasoning !== "string") return null;
+  return { modelId, providerId, ...reasoning !== void 0 && { reasoning } };
+}
+var MAX_BROWSER_CALL_BODY_BYTES = 64 * 1024;
+var MAX_WIDGET_BODY_BYTES = 64 * 1024;
+async function readWidgetAnswerBody(request) {
+  try {
+    const body = await readJsonBody(request, MAX_WIDGET_BODY_BYTES);
+    return typeof body === "object" && body !== null && !Array.isArray(body) && Object.hasOwn(body, "answer") ? body : null;
+  } catch (error) {
+    if (error instanceof RequestBodyTooLargeError) return null;
+    throw error;
+  }
+}
+function chatListOptions(chatList) {
+  return typeof chatList === "object" && chatList.subjectChats ? { subjects: "include" } : void 0;
+}
+function errorResponse2(status, kind) {
+  return Response.json({ error: { kind } }, { status });
+}
+function describe(error) {
+  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+function errorToResponse(error) {
+  if (error instanceof RequestBodyTooLargeError) return errorResponse2(413, "too_large");
+  if (error instanceof ChatNotFoundError) return errorResponse2(404, "not_found");
+  if (error instanceof InvalidChatTitleError) return errorResponse2(400, "invalid");
+  if (error instanceof InvalidMessageError) return errorResponse2(400, "invalid");
+  if (error instanceof AttachmentRejectedError) return Response.json({ error: { kind: error.kind } }, { status: 400 });
+  if (error instanceof InvalidModelChoiceError) return errorResponse2(400, "invalid");
+  if (error instanceof SpendingLimitReachedError) {
+    const { scope, period, resetsAt, timeZone, reason, windowId, hours, unit } = error;
+    const details = { ...timeZone && { timeZone }, ...reason && { reason }, ...windowId && { windowId }, ...hours !== void 0 && { hours }, ...unit && { unit } };
+    return Response.json({ error: { kind: "spending_limit_reached", scope, period, resetsAt, ...details } }, { status: 429 });
+  }
+  if (error instanceof TurnRefusedError) return turnRefusalResponse(error.refusal);
+  if (error instanceof ActionForbiddenError) {
+    return Response.json({ error: { kind: "action_forbidden", action: error.action, code: error.action, message: error.message } }, { status: 403 });
+  }
+  if (error instanceof ChatClosedError) return Response.json({ error: { kind: "chat_closed", code: error.code, message: error.message } }, { status: 409 });
+  if (error instanceof ChatCreationRefusedError) {
+    return Response.json({ error: { kind: "chat_creation_refused", code: error.code, message: error.message } }, { status: 403 });
+  }
+  if (error instanceof TooManyTurnsError) return Response.json({ error: { kind: "too_many_turns", limit: error.limit } }, { status: 429 });
+  if (error instanceof ChatBusyError) return errorResponse2(409, "busy");
+  if (error instanceof DuplicateMessageError) return errorResponse2(409, "invalid");
+  if (error instanceof NothingToRetryError) return errorResponse2(409, "invalid");
+  if (error instanceof ApprovalNotPendingError) return errorResponse2(409, "approval_not_pending");
+  if (error instanceof BrowserCallNotPendingError) return errorResponse2(409, "not_pending");
+  if (error instanceof WidgetNotPendingError) return errorResponse2(409, "widget_not_pending");
+  if (error instanceof InvalidWidgetAnswerError) return errorResponse2(400, "invalid_answer");
+  if (error instanceof WidgetAnswerRefusedError) {
+    return Response.json({ error: { kind: "widget_answer_refused", code: "widget_answer_refused", message: error.message } }, { status: 409 });
+  }
+  if (error instanceof WidgetAnswerCheckAbortedError) {
+    return Response.json({ error: { kind: "widget_answer_cancelled", code: "widget_answer_cancelled", message: error.message } }, { status: 409 });
+  }
+  if (error instanceof WidgetAnswerCheckTimeoutError) {
+    return Response.json({ error: { kind: "widget_check_timeout", code: "widget_check_timeout", message: error.message } }, { status: 504 });
+  }
+  return errorResponse2(500, "other");
+}
+
+// src/index.ts
+import { accessRefusedResponse as accessRefusedResponse2, allowedUser as allowedUser2 } from "@ykurilov/agent-chat-core";
+export {
+  accessRefusedResponse2 as accessRefusedResponse,
+  allowedUser2 as allowedUser,
+  createChatHandler,
+  createChatServer,
+  turnRefusalResponse
+};
+//# sourceMappingURL=index.js.map