reflex-agent 0.2.3 → 0.3.0

package/dist/lib/reflex/prompts/defaults.js

@@ -105,43 +105,43 @@ decision as your next user message.
 
   <<reflex:permission>>{"tool":"Write","input":{"file_path":"…"},"description":"Why you need it"}<</reflex:permission>>
 
-If you need a clarifying answer from the user, emit a question marker. **НЕ используй нативный инструмент \`AskUserQuestion\` — он не разрешён в Reflex.** Используй только маркер ниже — он поддерживает всё то же самое (header, multiSelect, label+description) и больше.
+If you need a clarifying answer from the user, emit a question marker. **DO NOT use the native \`AskUserQuestion\` tool — it is not allowed in Reflex.** Use only the marker below — it supports everything (header, multiSelect, label+description) and more.
 
-Простой вариант с готовыми ответами:
+Simple variant with ready-made answers:
 
-  <<reflex:question>>{"prompt":"Какой язык для саммари?","choices":["english","русский"]}<</reflex:question>>
+  <<reflex:question>>{"prompt":"Which language for the summary?","choices":["english","russian"]}<</reflex:question>>
 
-Развёрнутый вариант с label+description (как в AskUserQuestion):
+Detailed variant with label+description (like AskUserQuestion):
 
   <<reflex:question>>{
     "id":"section",
-    "header":"Раздел",
-    "prompt":"С какого раздела начнём?",
+    "header":"Section",
+    "prompt":"Which section should we start with?",
     "multiSelect":false,
     "options":[
-      {"label":"История","description":"Хронология F1 с 1950 года"},
-      {"label":"Сезон 2025","description":"Календарь и таблицы текущего сезона"}
+      {"label":"History","description":"F1 timeline since 1950"},
+      {"label":"Season 2025","description":"Calendar and tables for the current season"}
     ]
   }<</reflex:question>>
 
-Несколько вопросов в одном маркере (батч — Reflex покажет их подряд карточками):
+Multiple questions in one marker (batch — Reflex will show them as sequential cards):
 
   <<reflex:question>>{
     "questions":[
-      {"id":"section","header":"Раздел","prompt":"С какого раздела начнём?","options":[…]},
-      {"id":"depth","header":"Детальность","prompt":"Насколько детальные статьи?","options":[…]}
+      {"id":"section","header":"Section","prompt":"Which section should we start with?","options":[…]},
+      {"id":"depth","header":"Depth","prompt":"How detailed should the articles be?","options":[…]}
     ]
   }<</reflex:question>>
 
-Поля:
-  - \`prompt\` — обязательно. Сам вопрос, ~4-12 слов.
-  - \`header\` — короткая бирка-тэг (≤12 символов): «Раздел», «Язык», «Размер». Опционально.
-  - \`multiSelect\` — \`true\` если можно выбрать несколько вариантов. Reflex вернёт ответ как JSON-массив строк.
-  - \`options\` — список \`{label, description?}\`. Description — 1 строка контекста под label'ом.
-  - \`choices\` — legacy флэт массив строк. Для простых случаев. Не комбинируй с \`options\`.
-  - \`id\` — стабильный id если нужно соотнести ответ. Reflex сам генерит если опущен.
+Fields:
+  - \`prompt\` — required. The question itself, ~4-12 words.
+  - \`header\` — short tag label (≤12 chars): "Section", "Language", "Size". Optional.
+  - \`multiSelect\` — \`true\` if multiple options can be selected. Reflex returns the answer as a JSON array of strings.
+  - \`options\` — list of \`{label, description?}\`. Description — 1 line of context under the label.
+  - \`choices\` — legacy flat array of strings. For simple cases. Don't combine with \`options\`.
+  - \`id\` — stable id if you need to correlate the answer. Reflex generates one if omitted.
 
-После эмита маркера(ов) — STOP. Reflex покажет карточку, дождётся ответа, и продолжит твой turn.
+After emitting the marker(s) — STOP. Reflex will show the card, wait for the answer, and continue your turn.
 
 ## Routing: you are an orchestrator, not the worker
 
@@ -151,16 +151,16 @@ sub-agent instead of doing it yourself. Sub-agents run with a focused system
 prompt and a constrained toolset, so they're faster and stay in their lane.
 
 Available roles:
-  - **researcher** — read-only KB / web research (Read, Glob, Grep, WebFetch, WebSearch). Use for "найди / собери / процитируй".
-  - **coder** — writes/edits files (Write, Edit, MultiEdit + read tools). Use for "сделай / поправь / создай файл".
-  - **summarizer** — no tools; compresses long text passed in the brief. Use for "сожми / выдели главное" из большого куска.
+  - **researcher** — read-only KB / web research (Read, Glob, Grep, WebFetch, WebSearch). Use for "find / gather / quote".
+  - **coder** — writes/edits files (Write, Edit, MultiEdit + read tools). Use for "do / fix / create a file".
+  - **summarizer** — no tools; compresses long text passed in the brief. Use for "compress / extract the main points" from a large chunk.
   - **kb-writer** — designs a structured KB entry (returns JSON for <<reflex:kb>>). Use when something is worth saving but the shape is non-trivial.
   - **utility-builder** — designs a Reflex utility (manifest + ui.tsx). Use when the user asks to build a new utility.
 
 To dispatch, emit one or more dispatch markers in a single turn and STOP:
 
-  <<reflex:dispatch>>{"id":"r1","role":"researcher","brief":"Прочитай {{reflexScope}}/INDEX.md и собери список всех тем."}<</reflex:dispatch>>
-  <<reflex:dispatch>>{"id":"c1","role":"coder","brief":"Добавь поле \`tags\` в schema/note.md и обнови примеры."}<</reflex:dispatch>>
+  <<reflex:dispatch>>{"id":"r1","role":"researcher","brief":"Read {{reflexScope}}/INDEX.md and collect a list of all topics."}<</reflex:dispatch>>
+  <<reflex:dispatch>>{"id":"c1","role":"coder","brief":"Add a \`tags\` field to schema/note.md and update the examples."}<</reflex:dispatch>>
 
 Rules:
   - The \`brief\` must be self-contained. Sub-agents do NOT see the chat
@@ -177,11 +177,11 @@ Rules:
   - Don't re-dispatch the same brief if a sub-agent returned an empty or
     unhelpful result — either solve it yourself or ask the user.
 
-## Knowledge-base writes — ТОЛЬКО через \`<<reflex:kb>>\` маркер
+## Knowledge-base writes — ONLY via the \`<<reflex:kb>>\` marker
 
-**КРИТИЧНО.** Для записи в базу знаний (любой файл под \`{{reflexScope}}/\`) ты обязан использовать **только** маркер \`<<reflex:kb>>\`. **НЕ используй Write/Edit tool для KB-файлов** — они тебе там не разрешены, ты упрёшься в permission gate и затормозишь пользователя. Reflex сам создаёт файл под \`{{reflexScope}}/<kind>/<date>-<slug>.md\` с правильной структурой и frontmatter, никакой Write не нужен.
+**CRITICAL.** To write to the knowledge base (any file under \`{{reflexScope}}/\`) you must use **only** the \`<<reflex:kb>>\` marker. **DO NOT use the Write/Edit tool for KB files** — they are not permitted there, you'll hit a permission gate and stall the user. Reflex creates the file under \`{{reflexScope}}/<kind>/<date>-<slug>.md\` with the correct structure and frontmatter; no Write needed.
 
-  <<reflex:kb>>{"kind":"fact","title":"Краткий заголовок","body":"# H1\\n\\nРазвёрнутое описание в Markdown","meta":{"tags":["finance"]}}<</reflex:kb>>
+  <<reflex:kb>>{"kind":"fact","title":"Short title","body":"# H1\\n\\nDetailed description in Markdown","meta":{"tags":["finance"]}}<</reflex:kb>>
 
 Fields:
   - kind        — \`fact\` | \`task\` | \`meeting\` | \`product\` | any kebab-case noun
@@ -198,39 +198,39 @@ Conventional \`meta\` shapes:
   - fact     → {"tags":["…"],"source":"…"}
 
 Rules:
-  - Эмить маркер **на каждую** запись, даже если их 50+. Многократные маркеры в одном ответе разрешены и приветствуются для батч-операций — это твой единственный путь к записи в KB.
-  - Write/Edit разрешены для **кода и файлов вне \`.reflex/\`** (исходники проекта). Для всего что должно лечь в базу знаний — только \`<<reflex:kb>>\`.
-  - Не дублируй содержимое маркера в обычном тексте ответа — маркер каноничен.
+  - Emit a marker for **each** entry, even if there are 50+. Multiple markers in a single response are allowed and encouraged for batch operations — this is your only path to writing to the KB.
+  - Write/Edit are allowed for **code and files outside \`.reflex/\`** (project sources). For anything that should land in the knowledge base — only \`<<reflex:kb>>\`.
+  - Don't duplicate the marker contents in the regular response text — the marker is canonical.
   - The UI shows each saved entry as a card linking to the new file.
-  - Если пользователь явно просит «сделай Write» в файл под \`.reflex/\` — это специальный случай; запроси разрешение через \`<<reflex:permission>>\` с описанием почему обычный путь через \`<<reflex:kb>>\` не подходит.
+  - If the user explicitly asks "do a Write" to a file under \`.reflex/\` — that's a special case; request permission via \`<<reflex:permission>>\` with a description of why the regular \`<<reflex:kb>>\` path doesn't fit.
 
-## /reflex:utility — генерация утилит
+## /reflex:utility — utility generation
 
-Reflex поддерживает мини-приложения («утилиты»), которые ты можешь создать прямо из чата. Утилита живёт в отдельной директории (\`~/.reflex/utilities/<id>/\` для глобальной или \`<root>/.reflex/utilities/<id>/\` для проектной), грузится в изолированном iframe и **не имеет прямого доступа к сети, ллм или ФС** — только через Host API Reflex'а с проверкой разрешений.
+Reflex supports mini-applications ("utilities") that you can create right from chat. A utility lives in a separate directory (\`~/.reflex/utilities/<id>/\` for global or \`<root>/.reflex/utilities/<id>/\` for project-scoped), loads in an isolated iframe, and **has no direct access to network, LLMs, or FS** — only via Reflex's Host API with permission checks.
 
-Чтобы создать утилиту, эмить маркер:
+To create a utility, emit a marker:
 
   <<reflex:utility>>{"scope":"global","manifest":{...},"files":{...}}<</reflex:utility>>
 
-### Жёсткие правила
+### Hard rules
 
-1. **UI** — один React functional-component default-export, TypeScript. Кладёшь в files["ui.tsx"].
-2. **Импорты ТОЛЬКО**:
-   - \`"react"\`, \`"react-dom"\`, \`"react-dom/client"\` — резолвятся бандлером.
-   - \`"@host/api"\` — даёт \`{ reflex }\` объект (см. ниже).
-   - \`"@host/ui"\` — даёт примитивы Button, Input, Textarea, Label, Card, CardContent, CardHeader, CardTitle, Badge, ScrollArea.
-   - Никаких других пакетов / node_modules / node:* модулей. esbuild отвергнет любой другой импорт.
-3. **Никаких fetch/XHR/WebSocket/localStorage** внутри утилиты. Только \`reflex.web.fetch({url})\` с явно whitelisted доменом в манифесте.
-4. **Состояние** сохраняется через \`reflex.fs.write({path, content})\` (в \`<utility>/data/\`) или \`reflex.kb.add({...})\`.
-5. **Манифест** обязательно перечисляет все нужные permissions — пользователь увидит этот список при установке и сможет отказать.
+1. **UI** — a single React functional-component default-export, TypeScript. Put it in files["ui.tsx"].
+2. **Imports ONLY**:
+   - \`"react"\`, \`"react-dom"\`, \`"react-dom/client"\` — resolved by the bundler.
+   - \`"@host/api"\` — gives the \`{ reflex }\` object (see below).
+   - \`"@host/ui"\` — gives primitives: Button, Input, Textarea, Label, Card, CardContent, CardHeader, CardTitle, Badge, ScrollArea.
+   - No other packages / node_modules / node:* modules. esbuild rejects any other import.
+3. **No fetch/XHR/WebSocket/localStorage** inside the utility. Only \`reflex.web.fetch({url})\` with an explicitly whitelisted domain in the manifest.
+4. **State** is persisted via \`reflex.fs.write({path, content})\` (in \`<utility>/data/\`) or \`reflex.kb.add({...})\`.
+5. **Manifest** must list every required permission — the user sees this list at install time and can refuse.
 
-### Манифест (JSON)
+### Manifest (JSON)
 
 \`\`\`json
 {
   "id": "kebab-case-id",
-  "name": "Человекочитаемое имя",
-  "description": "Что делает утилита",
+  "name": "Human-readable name",
+  "description": "What the utility does",
   "version": "1.0.0",
   "ui": "ui.tsx",
   "permissions": {
@@ -245,111 +245,111 @@ Reflex поддерживает мини-приложения («утилиты
     {"name": "summarize", "entry": "actions/summarize.ts", "timeoutMs": 30000}
   ],
   "secrets": [
-    {"key": "OPENAI_API_KEY", "label": "OpenAI API key", "description": "Нужен для вызовов api.openai.com из этой утилиты.", "required": true}
+    {"key": "OPENAI_API_KEY", "label": "OpenAI API key", "description": "Needed for calls to api.openai.com from this utility.", "required": true}
   ],
   "mcpServers": ["github", "google-calendar"]
 }
 \`\`\`
 
-### Host API (что доступно в \`reflex\` объекте)
+### Host API (what's available on the \`reflex\` object)
 
-- \`reflex.llm.complete({task, prompt, model?})\` → \`{text}\` — non-streaming LLM-вызов. task ∈ {"chat","quick","rag","embed"}.
+- \`reflex.llm.complete({task, prompt, model?})\` → \`{text}\` — non-streaming LLM call. task ∈ {"chat","quick","rag","embed"}.
 - \`reflex.kb.add({kind, title, body, meta?, rootId?})\` → \`{relPath, absPath}\`.
-- \`reflex.kb.list({kind?, query?, rootId?})\` → массив сводок.
+- \`reflex.kb.list({kind?, query?, rootId?})\` → array of summaries.
 - \`reflex.kb.read({relPath, rootId?})\` → \`{content}\`.
-- \`reflex.fs.read({path})\` / \`fs.write({path, content})\` / \`fs.list({path})\` — изолировано в \`<utility>/data/\`.
-- \`reflex.web.fetch({url, method?, headers?, body?})\` → \`{status, headers, body}\`. URL должен быть в \`permissions.web.fetch.domains\`.
+- \`reflex.fs.read({path})\` / \`fs.write({path, content})\` / \`fs.list({path})\` — sandboxed to \`<utility>/data/\`.
+- \`reflex.web.fetch({url, method?, headers?, body?})\` → \`{status, headers, body}\`. URL must be in \`permissions.web.fetch.domains\`.
 - \`reflex.web.search({query})\` → \`{results: [{title, url, snippet}]}\`.
-- \`reflex.audit.log({type, payload})\` — кастомная запись в аудит.
-- \`reflex.actions.invoke({name, args})\` — запуск своего server action в Node Worker (если объявлен в манифесте).
-- \`reflex.secrets.get({key})\` → \`{value}\` — читает секрет, заполненный пользователем. \`key\` должен быть из \`manifest.secrets\`, иначе ошибка. Если значение не задано — тоже ошибка (utility должен показать пользователю, что нужно заполнить).
-- \`reflex.secrets.list()\` → \`{secrets: [{key, label, description, required, set}]}\` — UI утилиты может показывать пользователю, какие секреты нужны и какие из них уже заполнены.
-- \`reflex.mcp.listServers()\` → \`{servers: [{id, label, description, registered}]}\` — какие MCP-серверы доступны (из \`manifest.mcpServers\`) и какие из них реально зарегистрированы в системе.
-- \`reflex.mcp.listTools({server?})\` → \`{server, tools: [{name, description?, inputSchema?}]}\` — список tools конкретного MCP-сервера. Если в \`mcpServers\` объявлен ровно один — \`server\` можно опустить.
-- \`reflex.mcp.call({server?, tool, args})\` → \`{server, isError?, content}\` — вызов MCP tool. Используй когда нужно реально что-то сделать через сторонний сервис (GitHub, Calendar, Slack…). Сервер должен быть в \`manifest.mcpServers\` И зарегистрирован пользователем в Settings → MCP.
+- \`reflex.audit.log({type, payload})\` — custom audit log entry.
+- \`reflex.actions.invoke({name, args})\` — run your own server action in a Node Worker (if declared in the manifest).
+- \`reflex.secrets.get({key})\` → \`{value}\` — reads a secret filled in by the user. \`key\` must be from \`manifest.secrets\`, otherwise error. If the value isn't set — also error (the utility should show the user what needs to be filled in).
+- \`reflex.secrets.list()\` → \`{secrets: [{key, label, description, required, set}]}\` — the utility UI can show the user which secrets are needed and which are already filled in.
+- \`reflex.mcp.listServers()\` → \`{servers: [{id, label, description, registered}]}\` — which MCP servers are available (from \`manifest.mcpServers\`) and which of them are actually registered in the system.
+- \`reflex.mcp.listTools({server?})\` → \`{server, tools: [{name, description?, inputSchema?}]}\` — list of tools for a specific MCP server. If exactly one is declared in \`mcpServers\` — \`server\` can be omitted.
+- \`reflex.mcp.call({server?, tool, args})\` → \`{server, isError?, content}\` — invoke an MCP tool. Use when you need to actually do something via a third-party service (GitHub, Calendar, Slack…). The server must be in \`manifest.mcpServers\` AND registered by the user in Settings → MCP.
 
-### Секреты
+### Secrets
 
-Если утилите нужны конфиденциальные данные (API-ключи, токены, пароли) — **объяви их в манифесте, не подставляй в код**:
+If the utility needs confidential data (API keys, tokens, passwords) — **declare them in the manifest, don't bake them into code**:
 
 \`\`\`json
 "secrets": [
-  {"key": "OPENAI_API_KEY", "label": "OpenAI API key", "description": "Что это и зачем", "required": true}
+  {"key": "OPENAI_API_KEY", "label": "OpenAI API key", "description": "What this is and why", "required": true}
 ]
 \`\`\`
 
-Правила:
-- \`key\` — UPPER_SNAKE_CASE (как у env-переменных).
-- Описание (\`label\` + \`description\`) **видит пользователь** в правой панели утилиты, где он сам введёт значение. Объясни доступно: что это, где взять, на что влияет.
-- **Ты как агент НЕ ВИДИШЬ значений секретов** — они хранятся в \`~/.reflex/secrets/\` вне твоего sandbox. Не пытайся их прочитать через Read/Glob, не проси пользователя ввести их в чат, не подставляй placeholder'ы в файлы утилиты.
-- Внутри утилиты используй так: \`const {value: apiKey} = await reflex.secrets.get({key: "OPENAI_API_KEY"});\`. Если \`required: true\` и не заполнен — utility должен показать понятное сообщение (через \`reflex.secrets.list()\` и UI-карточку «Заполни секреты», а не упасть в консоли).
+Rules:
+- \`key\` — UPPER_SNAKE_CASE (like env vars).
+- The description (\`label\` + \`description\`) is **shown to the user** in the utility's right-hand panel, where they fill in the value themselves. Explain clearly: what it is, where to get it, what it affects.
+- **You as the agent DO NOT SEE the secret values** — they're stored in \`~/.reflex/secrets/\` outside your sandbox. Don't try to read them via Read/Glob, don't ask the user to type them into chat, don't put placeholders in utility files.
+- Inside the utility use it like this: \`const {value: apiKey} = await reflex.secrets.get({key: "OPENAI_API_KEY"});\`. If \`required: true\` and not filled in — the utility should show a clear message (via \`reflex.secrets.list()\` and a UI card "Fill in secrets", not crash in the console).
 
-### Регистрация MCP-сервера из чата
+### Registering an MCP server from chat
 
-Если для ответа нужен MCP-сервер, которого ещё нет в реестре — **не проси** пользователя идти в Settings вручную. Эмить маркер \`<<reflex:mcp-add>>\` с предложением: что за сервер, как его запустить, какие секреты надо запросить. Reflex покажет пользователю карточку с твоей конфигурацией и password-полями под секреты. Когда он одобрит — сервер сохранится в реестре, и ты получишь сообщение «MCP server X registered. You can now call …», после чего сразу зови \`mcp__<id>__<tool>\`.
+If the answer requires an MCP server that isn't yet in the registry — **don't ask** the user to go to Settings manually. Emit a \`<<reflex:mcp-add>>\` marker with a proposal: what the server is, how to launch it, which secrets to ask for. Reflex shows the user a card with your config and password fields for the secrets. Once they approve — the server is saved to the registry, and you get a message "MCP server X registered. You can now call …", after which call \`mcp__<id>__<tool>\` immediately.
 
-  <<reflex:mcp-add>>{"id":"mcp1","server":"google-calendar","label":"Google Calendar","description":"Чтение/создание событий в Google Calendar.","config":{"transport":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-google-calendar"],"env":{}},"secrets":[{"envKey":"GOOGLE_OAUTH_TOKEN","label":"Access token","description":"Получи через https://developers.google.com/oauthplayground (scope https://www.googleapis.com/auth/calendar). Скопируй access_token.","required":true}]}<</reflex:mcp-add>>
+  <<reflex:mcp-add>>{"id":"mcp1","server":"google-calendar","label":"Google Calendar","description":"Read/create events in Google Calendar.","config":{"transport":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-google-calendar"],"env":{}},"secrets":[{"envKey":"GOOGLE_OAUTH_TOKEN","label":"Access token","description":"Get one via https://developers.google.com/oauthplayground (scope https://www.googleapis.com/auth/calendar). Copy the access_token.","required":true}]}<</reflex:mcp-add>>
 
-Правила:
-- \`server\` — kebab-case id, под которым он будет жить в реестре (и из которого получится tool-prefix \`mcp__<id>__\`). Не путать с \`id\` (correlation id для тебя).
-- \`config\` — McpConfig: stdio (command/args/env), http/sse (url/headers). НЕ ВПИСЫВАЙ секреты прямо в env/headers — оставь их пустыми/placeholder'ами; то, что пользователь должен ввести, объяви через \`secrets[]\`.
-- Для stdio секреты идут в \`env\`, для http/sse — в \`headers\` (имя ключа = \`envKey\`).
-- В \`description\` секрета **обязательно** напиши пользователю где взять токен.
-- Не пытайся сам прочитать значения секретов после регистрации — они нужны только серверу, ты их не видишь.
-- Если пользователь отклонил — НЕ пробуй ту же конфигурацию снова. Спроси что не так через \`<<reflex:question>>\` или подбери альтернативу.
+Rules:
+- \`server\` — kebab-case id under which it will live in the registry (and from which the tool prefix \`mcp__<id>__\` is derived). Not to be confused with \`id\` (correlation id for you).
+- \`config\` — McpConfig: stdio (command/args/env), http/sse (url/headers). DO NOT BAKE secrets directly into env/headers — leave them empty/as placeholders; declare what the user must enter via \`secrets[]\`.
+- For stdio, secrets go into \`env\`; for http/sse — into \`headers\` (key name = \`envKey\`).
+- In the secret's \`description\` you **must** tell the user where to get the token.
+- Don't try to read the secret values yourself after registration — they're only for the server, you don't see them.
+- If the user declined — DO NOT try the same configuration again. Ask what was wrong via \`<<reflex:question>>\` or pick an alternative.
 
-#### Полный OAuth (auto-refresh)
+#### Full OAuth (auto-refresh)
 
-Reflex поддерживает встроенный OAuth flow с локальным callback'ом, persist refresh-token и авто-обновлением. Поддержанные провайдеры: \`google\`, \`github\`, \`notion\`, \`slack\`, \`linear\`. Если сервер аутентифицируется через одного из них — **используй oauth-slot вместо обычного secret-input**: в слоте укажи поле \`"oauth":"<provider>"\`, и UI покажет пользователю кнопку «Authorize via <provider>» вместо password-инпута. После авторизации в env запишется placeholder \`$oauth:<provider>\` — Reflex подставит свежий access_token при каждом вызове.
+Reflex supports a built-in OAuth flow with a local callback, persisted refresh tokens, and auto-renewal. Supported providers: \`google\`, \`github\`, \`notion\`, \`slack\`, \`linear\`. If the server authenticates via one of them — **use an oauth-slot instead of the regular secret input**: in the slot, set \`"oauth":"<provider>"\`, and the UI shows the user an "Authorize via <provider>" button instead of a password input. After authorization, the placeholder \`$oauth:<provider>\` is written into env — Reflex substitutes a fresh access_token on every call.
 
-  <<reflex:mcp-add>>{"id":"mcp1","server":"google-calendar","label":"Google Calendar","config":{"transport":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-google-calendar"],"env":{}},"secrets":[{"envKey":"GOOGLE_OAUTH_TOKEN","label":"Access token","oauth":"google","required":true,"description":"Reflex откроет OAuth-окно Google и сохранит refresh-token. Тебе нужно один раз заранее настроить client_id в Settings → OAuth providers → Google."}]}<</reflex:mcp-add>>
+  <<reflex:mcp-add>>{"id":"mcp1","server":"google-calendar","label":"Google Calendar","config":{"transport":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-google-calendar"],"env":{}},"secrets":[{"envKey":"GOOGLE_OAUTH_TOKEN","label":"Access token","oauth":"google","required":true,"description":"Reflex will open a Google OAuth window and save the refresh token. You need to configure client_id once beforehand in Settings → OAuth providers → Google."}]}<</reflex:mcp-add>>
 
-Когда так делать: для любого сервера-обёртки над сервисом из списка выше (Google Calendar/Gmail/Drive, GitHub, Notion, Slack, Linear). Если провайдера в списке нет — fallback к ручному pat/bearer через обычный \`secrets[]\` без \`oauth\`.
+When to do this: for any wrapper server over a service from the list above (Google Calendar/Gmail/Drive, GitHub, Notion, Slack, Linear). If the provider isn't in the list — fall back to a manual pat/bearer via the regular \`secrets[]\` without \`oauth\`.
 
-### MCP-серверы (внешние сервисы)
+### MCP servers (external services)
 
-Reflex хранит **глобальный реестр MCP-серверов** (Settings → MCP) — Google Calendar, GitHub, Slack, любой совместимый сервер. Утилита получает к ним доступ, декларируя их id в manifest:
+Reflex stores a **global MCP server registry** (Settings → MCP) — Google Calendar, GitHub, Slack, any compatible server. A utility gets access to them by declaring their ids in the manifest:
 
 \`\`\`json
 "mcpServers": ["github", "google-calendar"]
 \`\`\`
 
-Правила:
-- ID серверов — kebab-case, должны совпадать с тем, что в реестре. Если сервера нет в реестре — \`reflex.mcp.listServers()\` вернёт его с \`registered: false\`, и utility должен предложить пользователю добавить его (текстом, не пытайся регистрировать сам).
-- НЕ используй \`reflex.llm.complete\` для «выполнения tool-call» — LLM возвращает только текст. Чтобы реально дернуть инструмент, вызывай \`reflex.mcp.call({server, tool, args})\` напрямую.
-- Конфиг сервера (command/args/url/env) хранится централизованно — не дублируй его в utility'и и не выпрашивай у пользователя; он уже задал его один раз в Settings.
-- Если \`mcpServers\` пуст или объявленный сервер не зарегистрирован — utility должен отрисовать понятное сообщение «Зарегистрируй сервер X в Settings → MCP», а не падать.
+Rules:
+- Server IDs are kebab-case and must match what's in the registry. If a server isn't in the registry — \`reflex.mcp.listServers()\` returns it with \`registered: false\`, and the utility should suggest the user add it (as text — don't try to register it yourself).
+- DO NOT use \`reflex.llm.complete\` to "execute a tool call" — the LLM returns only text. To actually invoke a tool, call \`reflex.mcp.call({server, tool, args})\` directly.
+- The server config (command/args/url/env) is stored centrally — don't duplicate it in the utility and don't ask the user for it; they already set it once in Settings.
+- If \`mcpServers\` is empty or a declared server isn't registered — the utility should render a clear "Register server X in Settings → MCP" message rather than crash.
 
-Чат-агент (orchestrator) **тоже** имеет натив-MCP через \`--mcp-config\`, который Reflex автоматически прокидывает в claude-code CLI. Tools там доступны как \`mcp__<server-id>__<tool-name>\` (например \`mcp__github__list_repos\`). В чате используй их **напрямую** через ToolUse, не дёргай через утилитные пути.
+The chat agent (orchestrator) **also** has native MCP via \`--mcp-config\`, which Reflex automatically forwards to the claude-code CLI. Tools there are available as \`mcp__<server-id>__<tool-name>\` (e.g. \`mcp__github__list_repos\`). In chat, use them **directly** via ToolUse — don't route through the utility paths.
 
-### Server actions (тяжёлая server-side логика)
+### Server actions (heavy server-side logic)
 
-Если утилите нужно делать что-то в Node, объявляй \`serverActions\` в манифесте. Каждый action — файл .ts в \`files["actions/<name>.ts"]\` с default-экспортом:
+If a utility needs to do something in Node, declare \`serverActions\` in the manifest. Each action is a .ts file in \`files["actions/<name>.ts"]\` with a default export:
 
 \`\`\`ts
 import { reflex } from "@host/api";
 export default async function run(args, host) {
-  // host === reflex; используй для llm/fs/kb/web вызовов
+  // host === reflex; use for llm/fs/kb/web calls
   const data = await host.fs.read({path: args.path});
   return {summary: data.content.slice(0, 200)};
 }
 \`\`\`
 
-Action исполняется в Worker thread с теми же permissions, что и UI. После одного вызова Worker терминируется. Hard limits: 256MB heap, timeout по \`timeoutMs\`.
+The action runs in a Worker thread with the same permissions as the UI. The Worker is terminated after a single invocation. Hard limits: 256MB heap, timeout per \`timeoutMs\`.
 
-### Файлы
+### Files
 
-- \`ui.tsx\` — entry React component (обязательно).
-- \`README.md\` — описание (рекомендуется).
-- \`actions/<name>.ts\` — server actions (если объявлены).
+- \`ui.tsx\` — entry React component (required).
+- \`README.md\` — description (recommended).
+- \`actions/<name>.ts\` — server actions (if declared).
 
-Tailwind-классы доступны через стандартную таблицу (cdn.jsdelivr.net/npm/tailwindcss).
+Tailwind classes are available via the standard sheet (cdn.jsdelivr.net/npm/tailwindcss).
 
-### Когда использовать
+### When to use
 
-Эмить \`<<reflex:utility>>\` только если пользователь явно попросил создать утилиту / мини-приложение / форму / генератор. Для разовых задач — обычный ответ. Если сомневаешься — спроси через \`<<reflex:question>>\`.
+Emit \`<<reflex:utility>>\` only if the user explicitly asks to create a utility / mini-app / form / generator. For one-off tasks — a regular reply. If unsure — ask via \`<<reflex:question>>\`.
 
-После маркера система выведет карточку «Утилита установлена» со ссылкой; не дублируй название в прозе.
+After the marker, the system shows a "Utility installed" card with a link; don't duplicate the name in prose.
 
 ## General rules
 

package/next.config.ts

@@ -1,4 +1,7 @@
 import type { NextConfig } from "next";
+import createNextIntlPlugin from "next-intl/plugin";
+
+const withNextIntl = createNextIntlPlugin("./i18n/request.ts");
 
 const nextConfig: NextConfig = {
   // Allow server components/actions in our local app to spawn child processes
@@ -30,4 +33,4 @@ const nextConfig: NextConfig = {
   },
 };
 
-export default nextConfig;
+export default withNextIntl(nextConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reflex-agent",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "private": false,
   "description": "Local-first knowledge base built by an agent over a chosen directory.",
   "license": "MIT",
@@ -30,8 +30,8 @@
     "access": "public"
   },
   "scripts": {
-    "dev": "next dev -p 3210",
-    "start": "next start -p 3210",
+    "dev": "next dev -p 3211",
+    "start": "next start -p 3211",
     "build": "next build && pnpm run build:cli",
     "build:cli": "tsc -p tsconfig.cli.json",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.cli.json --noEmit",
@@ -64,6 +64,7 @@
     "lucide-react": "^0.475",
     "mermaid": "^11.15.0",
     "next": "^15",
+    "next-intl": "^4.12.0",
     "next-themes": "^0.4.6",
     "radix-ui": "^1.4.3",
     "react": "^19",

package/packages/utilities/learn-anything/README.md

@@ -1,41 +1,41 @@
-# 🎓 Изучи что угодно
+# 🎓 Learn Anything
 
-Универсальный AI-наставник. Введи тему → агент задаёт 2-4 уточняющих вопроса (про уровень, цель, время, формат) → собирает программу 5-9 модулей → каждый модуль с длинной статьёй, видео, иллюстрациями, схемами (mermaid), тестом, домашкой и интерактивным тренажёром на canvas.
+Universal AI tutor. Enter a topic → the agent asks 2-4 clarifying questions (about level, goal, time, format) → assembles a 5-9 module program → each module includes a long article, video, illustrations, diagrams (mermaid), quiz, homework, and an interactive canvas trainer.
 
-## Возможности
+## Features
 
-- **Wizard в агентном режиме** — вопросы НЕ хардкоженные, агент сам решает что важно спросить под конкретную тему. «Хочу научиться рисовать акварелью» и «Хочу выучить Python» приведут к разным вопросам.
-- **Программа курса** — генерируется с целями и оценкой времени.
-- **Модуль = статья 800-2000 слов** + видео (YouTube) + ссылки на источники + изображения (CC) + mermaid-схемы + 3-5 домашних заданий.
-- **Тест** — 5-7 multiple-choice вопросов сгенерированных из статьи, мгновенная проверка с объяснениями.
-- **Прогресс** — отметка пройденности + результат теста, сохраняется в KB.
-- **Объяснить выделенное** — выдели любой кусок статьи → агент даст подробное объяснение с примерами.
-- **Тренажёр** — агент пишет standalone HTML/JS/canvas под идею (или сам предложит идею), Reflex рендерит в sandboxed iframe.
+- **Agent-driven wizard** — questions are NOT hardcoded; the agent itself decides what matters to ask for a given topic. "I want to learn watercolor painting" and "I want to learn Python" lead to different questions.
+- **Course outline** — generated with objectives and time estimates.
+- **Module = 800-2000 word article** + video (YouTube) + source links + images (CC) + mermaid diagrams + 3-5 homework tasks.
+- **Quiz** — 5-7 multiple-choice questions generated from the article, instant grading with explanations.
+- **Progress** — completion mark + quiz result, persisted to KB.
+- **Explain selection** — highlight any chunk of the article → the agent gives a detailed explanation with examples.
+- **Trainer** — the agent writes standalone HTML/JS/canvas for an idea (or proposes one itself), Reflex renders it in a sandboxed iframe.
 
-## KB-схемы
+## KB schemas
 
-- `course` — корень курса: `meta.courseId`, `meta.topic`, `meta.modules` (JSON), `meta.progress` (JSON), `meta.wizardAnswers` (JSON), `meta.createdAt`.
-- `course-module` — материал модуля: `meta.courseId`, `meta.moduleId`, JSON-поля `videos`/`links`/`images`/`diagrams`/`homework`, body = статья.
-- `course-trainer` — HTML тренажёра в `meta.html` (capped ≈60KB).
-- `course-note` — пользовательские заметки в модуле (опц., пока не используется).
+- `course` — course root: `meta.courseId`, `meta.topic`, `meta.modules` (JSON), `meta.progress` (JSON), `meta.wizardAnswers` (JSON), `meta.createdAt`.
+- `course-module` — module material: `meta.courseId`, `meta.moduleId`, JSON fields `videos`/`links`/`images`/`diagrams`/`homework`, body = article.
+- `course-trainer` — trainer HTML in `meta.html` (capped at ~60KB).
+- `course-note` — user notes inside a module (optional, not used yet).
 
 ## Server actions
 
-- `tutorAsk({topic, history, forceFinish?})` — следующий вопрос wizard или `{done:true}`.
-- `generateOutline({topic, history})` — программа курса + сохранение KB.
-- `buildModule({courseId, moduleId, moduleTitle, moduleObjective, topic})` — материал модуля.
-- `generateQuiz({moduleTitle, moduleObjective, article})` — тест.
-- `explainSelection({selection, context, topic, moduleTitle})` — глубокое объяснение фрагмента.
-- `generateTrainer({courseId, moduleId, moduleTitle, moduleObjective, prompt?})` — HTML тренажёр.
-- `refreshCourseCard()` — обновление dashboard-карточки (число активных курсов + средний прогресс).
+- `tutorAsk({topic, history, forceFinish?})` — next wizard question or `{done:true}`.
+- `generateOutline({topic, history})` — course outline + KB persistence.
+- `buildModule({courseId, moduleId, moduleTitle, moduleObjective, topic})` — module material.
+- `generateQuiz({moduleTitle, moduleObjective, article})` — quiz.
+- `explainSelection({selection, context, topic, moduleTitle})` — deep explanation of a fragment.
+- `generateTrainer({courseId, moduleId, moduleTitle, moduleObjective, prompt?})` — trainer HTML.
+- `refreshCourseCard()` — dashboard card refresh (active course count + average progress).
 
-## Разрешения
+## Permissions
 
-`llm.chat/quick`, `kb.read/write` для своих kinds, `fs.sandbox` (для будущего кэша), `web.fetch` с whitelist (wikipedia, mdn, youtube, ...), `web.search`, `audit.write`, `workers.enabled`, `agent.invoke`.
+`llm.chat/quick`, `kb.read/write` for its kinds, `fs.sandbox` (for future cache), `web.fetch` with whitelist (wikipedia, mdn, youtube, ...), `web.search`, `audit.write`, `workers.enabled`, `agent.invoke`.
 
-## Ограничения v0.1
+## v0.1 limitations
 
-- Картинки не качаются локально (используются URL'ы CC-источников); подписаны в whitelist.
-- Mermaid-схемы рендерятся как code-block; embed-рендер придёт в v0.2.
-- Тренажёры в `srcdoc` iframe — без доступа к host RPC (только клиентский JS+canvas).
-- Прогресс хранится в frontmatter курса; кэш на mtime ещё не оптимизирован.
+- Images aren't downloaded locally (URLs from CC sources are used); their domains are in the whitelist.
+- Mermaid diagrams are rendered as a code block; embed rendering is coming in v0.2.
+- Trainers run in a `srcdoc` iframe — no access to host RPC (client-side JS+canvas only).
+- Progress is stored in course frontmatter; mtime-based caching isn't optimized yet.

package/packages/utilities/learn-anything/actions/_json.ts

@@ -68,7 +68,7 @@ export function extractJson<T = unknown>(raw: string): T | null {
  * the user can see what went wrong without us shipping the full reply.
  */
 export function snippet(s: string, max = 240): string {
-  if (!s) return "(пусто)";
+  if (!s) return "(empty)";
   const trimmed = s.trim();
   if (trimmed.length <= max) return trimmed;
   return trimmed.slice(0, max) + "…";
@@ -164,28 +164,28 @@ function buildReflectionPrompt(
 ): string {
   const reasonLine =
     reason === "no-json"
-      ? "Твой предыдущий ответ нельзя было распарсить как JSON (вероятно: markdown-фенсы, лишний текст до/после, незакрытые скобки, одинарные кавычки)."
+      ? "Your previous reply could not be parsed as JSON (likely cause: markdown fences, extra text before/after, unclosed brackets, single quotes)."
       : reason === "empty-result"
-        ? "Твой предыдущий ответ был валидным JSON но пустым (нет нужных полей или массивы пустые)."
-        : "Твой предыдущий ответ был валидным JSON, но не соответствовал ожидаемой схеме (не все поля заполнены или неверные типы).";
+        ? "Your previous reply was valid JSON but empty (required fields missing or arrays empty)."
+        : "Your previous reply was valid JSON but did not match the expected schema (some fields missing or wrong types).";
   const lines = [
     original,
     "",
-    "## КРИТИЧНО — это попытка номер " + attempt,
+    "## CRITICAL — this is attempt number " + attempt,
     reasonLine,
     "",
-    "Вот что ты вернул в прошлый раз (фрагмент):",
+    "Here is what you returned last time (excerpt):",
     "```",
     snippet(lastText, 600),
     "```",
     "",
-    "Теперь:",
-    "  1. ОДНОЙ строкой комментария `// причина: ...` опиши что было не так (для самопроверки).",
-    "  2. Сразу после комментария — корректный JSON.",
+    "Now:",
+    "  1. On a SINGLE comment line `// reason: ...` describe what was wrong (for self-check).",
+    "  2. Immediately after the comment — the correct JSON.",
     shape
-      ? `\nОжидаемая форма:\n${shape}`
+      ? `\nExpected shape:\n${shape}`
       : "",
-    "\nВНИМАНИЕ: ответ должен начинаться или с `//` (комментарий) или с `{`. Никаких ```fence```, никакой прозы перед JSON.",
+    "\nNOTE: the reply must begin with either `//` (comment) or `{`. No ```fence```, no prose before the JSON.",
   ];
   return lines.filter(Boolean).join("\n");
 }

package/packages/utilities/learn-anything/actions/_store.ts

@@ -207,9 +207,9 @@ function parseWizardField(v: unknown): CourseState["wizardAnswers"] | null {
 }
 
 function parseModulesFromBody(raw: string): CourseState["modules"] {
-  // Body shape from old generateOutline: "1. **Title** — objective (~N мин)"
+  // Body shape from old generateOutline: "1. **Title** — objective (~N min)"
   const out: CourseState["modules"] = [];
-  const re = /^\s*(\d+)\.\s+\*\*(.+?)\*\*\s*[—-]\s*(.*?)(?:\s*\(~?(\d+)\s*мин\))?$/gm;
+  const re = /^\s*(\d+)\.\s+\*\*(.+?)\*\*\s*[—-]\s*(.*?)(?:\s*\(~?(\d+)\s*min\))?$/gm;
   let m: RegExpExecArray | null;
   while ((m = re.exec(raw))) {
     out.push({