@ykurilov/agent-chat-core 0.55.0 → 0.56.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @ykurilov/agent-chat-core
 
+## 0.56.0
+
+### Minor Changes
+
+- 24c313e: Новый пакет `@ykurilov/agent-chat-mcp`: серверы MCP, которые подключает админ приложения.
+  
+  - `createMcpServers({ store, secretKey, isAdmin, proxy?, spending?, limits?, syncIntervalMs? })` → `mcp.tools(model, appTools?)`
+    для `agent.tools` (первым; при одинаковом имени побеждает инструмент приложения), `mcp.admin`, `mcp.reload()`, `mcp.sync()`, `mcp.close()`. «Только админы» — по `model.viewer.isAdmin`;
+    `isAdmin` (может быть асинхронной) — для экрана. Правка доходит до всех копий сервера по отметке версии в хранилище. Только удалённые серверы (Streamable HTTP, SSE). Инструменты — из
+    сохранённого снимка списка: запрос к модели стабилен, упавший сервер не ломает начало запроса. Соединение — на
+    проверенный адрес DNS; заголовки прокси — только на `proxy.origin`.
+  - `createMcpAdminHandler({ mcp, resolveUser, allowedOrigins })` — адреса `/api/mcp`, не админу 404.
+  - Хранилища: `createMemoryMcpStore`, `/sqlite` `createSqliteMcpStore`, `/postgres` `createPostgresMcpStore`; миграции сами.
+  - `/react`: `McpAdmin`, `useMcpAdmin`, договор скина `McpSkin` v1 (с формой правки `McpServerCardView.edit`), надписи ru/en. Скин Тандема: `./mcp` → `tandemMcpSkin`.
+  - Ядро: штатный вид расхода `mcp_tool`; `agent.viewer` — права человека раз в начале хода, полем `viewer` в
+    `contextBlocks` и `AgentToolsModel`. Песочница: права тестового чата — по владельцу чата. web-tools: наружу `dnsHostResolver`.
+
 ## 0.55.0
 
 ### Minor Changes

package/dist/{chunk-PWW3R3VL.js → chunk-7M7M7DAN.js}

@@ -41,7 +41,8 @@ var BUILT_IN_USAGE_SOURCES = [
   "judge",
   "first_message",
   "voice_input",
-  "voice_polish"
+  "voice_polish",
+  "mcp_tool"
 ];
 
 // src/conversation/branches.ts
@@ -2284,6 +2285,57 @@ function jsonBytes(value) {
   }
 }
 
+// src/agent-run/agent-viewer.ts
+var AgentViewerError = class extends Error {
+  constructor(message, options2) {
+    super(message, options2);
+    this.name = "AgentViewerError";
+  }
+};
+async function resolveAgentViewer(source, input) {
+  input.abortSignal.throwIfAborted();
+  let viewer;
+  try {
+    viewer = await Promise.race([
+      Promise.resolve().then(() => source(input)),
+      new Promise((_, reject) => input.abortSignal.addEventListener("abort", () => reject(input.abortSignal.reason), { once: true }))
+    ]);
+  } catch (error) {
+    if (input.abortSignal.aborted) throw error;
+    throw new AgentViewerError(`agent.viewer \u0431\u0440\u043E\u0441\u0438\u043B\u0430: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  if (typeof viewer !== "object" || viewer === null || Array.isArray(viewer)) throw new AgentViewerError("agent.viewer \u0432\u0435\u0440\u043D\u0443\u043B\u0430 \u043D\u0435 \u043E\u0431\u044A\u0435\u043A\u0442");
+  return Object.freeze({ ...viewer });
+}
+function viewerInput(turn) {
+  const ownerId = turn.ownerId ?? "";
+  return {
+    userId: turn.staff?.id ?? ownerId,
+    chatId: turn.chatId,
+    ownerId,
+    messageId: turn.messageId,
+    chat: structuredClone({ ...turn.chatData && { data: turn.chatData } }),
+    ...turn.subject && { subject: structuredClone(turn.subject) },
+    channel: turn.channel ?? "web",
+    audience: turn.audience,
+    ...turn.staff && { staff: structuredClone(turn.staff) },
+    abortSignal: turn.abortSignal
+  };
+}
+var VIEWER_OUTSIDE_TURN_TIMEOUT_MS = 1e4;
+async function resolveViewerOutsideTurn(source, turn, signal) {
+  const deadline = new AbortController();
+  const timer = setTimeout(
+    () => deadline.abort(new AgentViewerError(`agent.viewer \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B\u0430 \u0437\u0430 ${VIEWER_OUTSIDE_TURN_TIMEOUT_MS / 1e3} \u0441`)),
+    VIEWER_OUTSIDE_TURN_TIMEOUT_MS
+  );
+  try {
+    return await resolveAgentViewer(source, viewerInput({ ...turn, abortSignal: signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal }));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/helpers/run-helper.ts
 import { generateText as generateText2, stepCountIs as stepCountIs2 } from "ai";
 
@@ -5436,6 +5488,7 @@ async function freezeTurnContext(input, turn, base, place) {
         channel: input.channel ?? "web",
         audience: input.group ? "group" : "private",
         ...input.staff && { staff: structuredClone(input.staff) },
+        ...turn.viewer && { viewer: turn.viewer },
         modelId: input.modelId,
         providerId: input.providerId
       }
@@ -5577,10 +5630,12 @@ async function runTurn(turnInput, emitRaw) {
     let errorKind;
     let providerId = input.providerId;
     let answeredProviderId = input.providerId;
+    let viewer;
     try {
       const { history: historySource } = input;
       const fullHistory = typeof historySource === "function" ? await historySource() : historySource;
       const branchState = input.appState ?? foldAppState(fullHistory);
+      viewer = input.viewer && await resolveAgentViewer(input.viewer, viewerInput({ ...input, audience: input.group ? "group" : "private" }));
       const prepared = input.prepareTurn && await input.prepareTurn({ state: branchState, abortSignal: input.abortSignal });
       const turnNotices = prepared && prepared.notices.length > 0 ? prepared.notices : void 0;
       const stateBase = prepared?.state ?? branchState;
@@ -5596,10 +5651,11 @@ async function runTurn(turnInput, emitRaw) {
       const frozenOfTurn = await frozenContextForTurn(input, {
         history: answer.request().history,
         answer: resume?.message ?? fullHistory.find((message) => message.id === messageId),
-        state: publicAppState(appState.values())
+        state: publicAppState(appState.values()),
+        ...viewer && { viewer }
       });
       const frozen = turnNotices && frozenOfTurn.fresh ? { ...frozenOfTurn, data: { ...frozenOfTurn.data, notices: turnNotices } } : frozenOfTurn;
-      let resumeNote = resume && !resume.replay && !frozen.fresh ? await resumeNoteForTurn(input, { history: answer.request().history, answer: resume.message, state: publicAppState(appState.values()) }) : void 0;
+      let resumeNote = resume && !resume.replay && !frozen.fresh ? await resumeNoteForTurn(input, { history: answer.request().history, answer: resume.message, state: publicAppState(appState.values()), ...viewer && { viewer } }) : void 0;
       if (resume && turnNotices && !frozen.fresh) {
         const seen = latestFrozenContextOf(resume.message.parts);
         if (seen) resumeNote = { ...resumeNote ?? { blocks: seen.blocks, sent: { changed: [], removed: [] }, base: messageId }, notices: turnNotices };
@@ -5629,7 +5685,7 @@ async function runTurn(turnInput, emitRaw) {
       if (resume && !resume.replay) {
         const continued = helpersToContinue(resume.message.parts);
         if (continued.length > 0) {
-          await continueHelpers(input, continued, { toolQueue, dataChanges, appEvents, chatClosure, appState, emit, logError });
+          await continueHelpers(input, continued, { ...viewer && { viewer }, toolQueue, dataChanges, appEvents, chatClosure, appState, emit, logError });
           const parts2 = await saver.snapshot();
           answer.update(parts2, { modelId, providerId: answeredProviderId });
           mainLoopWaits = input.abortSignal.aborted || pendingHumanInput(parts2, input.waitingWidgets).length > 0;
@@ -5671,6 +5727,7 @@ async function runTurn(turnInput, emitRaw) {
             steps: { done: stepsDone, max: maxSteps, beforeResume: stepsBeforeResume },
             historyRewritten,
             frozenContext: frozen.data,
+            ...viewer && { viewer },
             toolQueue,
             endTurns,
             browser,
@@ -5853,7 +5910,8 @@ async function runTurn(turnInput, emitRaw) {
       }
     } catch (error2) {
       if (!input.abortSignal.aborted) {
-        errorKind = classifyProviderError(error2, void 0);
+        if (error2 instanceof AgentViewerError) logError(`[agent.viewer] \u0447\u0430\u0442=${input.chatId} \u0445\u043E\u0434 \u043D\u0435 \u043D\u0430\u0447\u0430\u0442: ${error2.message}`);
+        errorKind = error2 instanceof AgentViewerError ? "other" : classifyProviderError(error2, void 0);
         errors = [{ type: "error", errorText: errorKind }];
       }
     }
@@ -6462,6 +6520,7 @@ function turnToolsModel(input, found, turn) {
     ...input.subject && { subject: input.subject },
     chat: { ...input.chatData && { data: input.chatData } },
     ...input.staff && { staff: input.staff },
+    ...turn.viewer && { viewer: turn.viewer },
     ...input.closeChat && { closeChat: turn.chatClosure.request },
     // Инструменту — только чтение и запись: конец записи и служебные ключи — дело ядра.
     state: { get: turn.appState.get, set: turn.appState.set, unset: turn.appState.unset }
@@ -9717,7 +9776,7 @@ function createCompactionService(options2) {
         chatId,
         model,
         instructions: await instructionsOf(chat),
-        tools: resolveTools(model, chat, chatId, ownerId),
+        tools: await resolveTools(model, chat, chatId, ownerId, branch, signal),
         ...options2.switchableTools && { switchableTools: options2.switchableTools },
         ...observation(ownerId, answerId),
         history,
@@ -9764,19 +9823,26 @@ function createCompactionService(options2) {
   function observation(ownerId, answerId) {
     return options2.turnObserver ? { observe: { observer: options2.turnObserver, ownerId, messageId: answerId ?? null } } : {};
   }
-  function resolveTools(model, chat, chatId, ownerId) {
-    const { tools } = options2.agent;
+  async function resolveTools(model, chat, chatId, ownerId, branch, signal) {
+    const { tools, viewer: viewerSource } = options2.agent;
     if (typeof tools !== "function") return tools;
     const subject = chat ? subjectOfChat(chat) : void 0;
+    const chatData = chat ? chatDataOfInput(chat) : void 0;
+    const { channel, group } = turnChannelOf(branch);
+    const audience = group ? "group" : "private";
+    const viewer = viewerSource && await resolveViewerOutsideTurn(viewerSource, { chatId, ownerId, messageId: "", ...chatData && { chatData }, ...subject && { subject }, channel, audience }, signal);
     return tools({
       profile: findModel(catalog, model.modelId, model.providerId).profile,
       providerId: model.providerId,
       chatId,
       ownerId,
       place: null,
+      channel,
+      audience,
       notifyDataChanged: (change) => logError(`\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 \u0441\u043E\u043E\u0431\u0449\u0438\u043B \u043E\u0431 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0438 \u0434\u0430\u043D\u043D\u044B\u0445 \xAB${String(change?.tag)}\xBB \u0432\u043E \u0432\u0440\u0435\u043C\u044F \u0441\u0436\u0430\u0442\u0438\u044F \u0447\u0430\u0442\u0430 ${chatId}: \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043D\u0435 \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u043E`),
       ...subject && { subject },
-      chat: { ...chat && chatDataOfInput(chat) && { data: chatDataOfInput(chat) } }
+      chat: { ...chatData && { data: chatData } },
+      ...viewer && { viewer }
     });
   }
   return {
@@ -9853,7 +9919,7 @@ function createCompactionService(options2) {
           chatId,
           model,
           instructions: await instructionsOf(chat),
-          tools: resolveTools(model, chat, chatId, ownerId),
+          tools: await resolveTools(model, chat, chatId, ownerId, history, abortSignal),
           ...options2.switchableTools && { switchableTools: options2.switchableTools },
           ...observation(ownerId, answerId),
           history: [...history, { id: `${chatId}-answer-steps`, role: "assistant", parts: steps }],
@@ -12632,6 +12698,9 @@ function createChatService(input) {
         const choice = effectiveChoiceOfChat(options2.catalog, env, chat, defaultChoice);
         const found = findModel(options2.catalog, choice.modelId, choice.providerId);
         const subject = subjectOfChat(chat);
+        const { channel, group } = turnChannelOf(await loadCurrentBranch(storage, chatId));
+        const audience = group ? "group" : "private";
+        const viewer = options2.agent.viewer && await resolveViewerOutsideTurn(options2.agent.viewer, { chatId, ownerId, messageId: "", chatData: chatDataOfInput(chat), subject, channel, audience });
         const model = {
           profile: found.profile,
           providerId: found.provider.id,
@@ -12641,11 +12710,12 @@ function createChatService(input) {
           // Вкладки у фоновой задачи нет: сообщать об изменённых данных некому.
           notifyDataChanged: () => {
           },
-          channel: "web",
-          audience: "private",
+          channel,
+          audience,
           messageId: "",
           ...subject && { subject },
-          chat: { ...chatDataOfInput(chat) && { data: chatDataOfInput(chat) } }
+          chat: { ...chatDataOfInput(chat) && { data: chatDataOfInput(chat) } },
+          ...viewer && { viewer }
         };
         return helperToolsModel(model, {
           storage,
@@ -12856,6 +12926,7 @@ export {
   ChatClosedError,
   isScreenPlaceInput,
   isTabId,
+  AgentViewerError,
   runHelper,
   MAX_SERVER_TURNS_IN_ROW,
   createChatEvents,
@@ -12928,4 +12999,4 @@ export {
   InvalidWidgetAnswerError,
   createChatService
 };
-//# sourceMappingURL=chunk-PWW3R3VL.js.map
+//# sourceMappingURL=chunk-7M7M7DAN.js.map