chore: sync local dev branch

Author: Grigory Rylov

.mimocode/plans/1781675933910-neon-mountain.md

@@ -0,0 +1,48 @@
+# Plan: Reproduce Bun 5-minute fetch timeout
+
+## Problem
+
+Bun хардкодит 5-минутный таймаут на `globalThis.fetch` (oven-sh/bun#16682). Когда LLM-провайдер (llama-server) думает дольше 5 минут, `FetchHttpClient` в `executor.ts` получает `TimeoutError` ровно через 5 минут. AI SDK путь (`aisdk.ts`) уже защищён через `timeout: false`, но нативный LLM путь — нет.
+
+## Что делаем
+
+Создаём standalone-скрипт (не bun:test — у bun:test дефолтный таймаут 30с), который:
+
+1. Запускает `Bun.serve` сервер, который держит соединение 6 минут перед ответом
+2. Делает `fetch()` с `AbortSignal.timeout(30 * 60 * 1000)` (30 мин) — чтобы убедиться, что это НЕ наш таймаут срабатывает
+3. Логирует ошибку — ожидаем `TimeoutError` ровно через ~5 минут
+4. Затем повторяет запрос с `timeout: false` (Bun-specific) — должен завершиться успешно
+
+## Файл
+
+`packages/llm/test/bun-fetch-timeout-repro.ts` — standalone скрипт, запускается через `bun run`
+
+## Детали скрипта
+
+Два теста, каждый с задержкой ответа 6 минут:
+
+```
+// Test 1 — проблема (без timeout:false):
+//   Bun.serve: delay 6 min → fetch({ signal: AbortSignal.timeout(30 min) })
+//   → Ожидаем TimeoutError через ~5 мин (Bun's hardcoded limit)
+//
+// Test 2 — фикс (с timeout:false):
+//   Bun.serve: delay 6 min → fetch({ signal: AbortSignal.timeout(30 min), timeout: false })
+//   → Ожидаем успешный ответ через 6 мин
+```
+
+Оба теста запускаются параллельно (Promise.all), общее время ~6.5 мин.
+
+## Как проверить
+
+```bash
+bun run packages/llm/test/bun-fetch-timeout-repro.ts
+```
+
+Скрипт выведет:
+- Test 1: `FAIL: TimeoutError after ~5 min` — подтверждает проблему
+- Test 2: `OK: Response received after ~6 min` — подтверждает фикс через `timeout: false`
+
+## Следующий шаг (после подтверждения)
+
+Применить фикс в `packages/llm/src/route/executor.ts` — переопределить `FetchHttpClient.Fetch` через `Layer.succeed(FetchHttpClient.Fetch, customFetch)` с `timeout: false` + `AbortSignal.timeout(30 min)`.

bot/config.py

@@ -15,10 +15,9 @@
     "thinking_peer_id": 2000000506,
     "llama_server_path": "llama-server",
     "llama_server_host": "http://localhost:8081",  # URL удалённого llama-server
-    "opencode_config_path": "~/.config/opencode/opencode.json",
+    "opencode_config_path": "~/.config/lildax/config.json",
     "models": [],
     "default_model": "qwen3.5-122b",
-    "request_timeout": 1800000,
 }
 
 
@@ -92,9 +91,6 @@ def load_config(config_path: str = "config.json") -> dict:
 # Provider URL for CLI --provider-url flag (LLAMA_SERVER_HOST + /v1)
 PROVIDER_URL = (args.llama_host or LLAMA_SERVER_HOST).rstrip("/") + "/v1"
 
-# Request timeout for CLI --timeout flag (milliseconds, default 30 minutes)
-REQUEST_TIMEOUT = CONFIG.get("request_timeout", 1800000)
-
 # Model для --model флага, через CLI аргумент или из конфига.
 # Разрешаем алиас в реальное имя модели (через MODELS[alias].model)
 _default_alias = args.model or DEFAULT_MODEL
@@ -160,7 +156,6 @@ def switch_config(config_name: str) -> bool:
         current_module.OPENCODE_BIN = (SCRIPT_DIR / current_module.OPENCODE_BIN).resolve()
     current_module.OPENCODE_CONFIG_PATH = Path(new_config.get("opencode_config_path", "~/.config/opencode/opencode.json")).expanduser()
     current_module.PROVIDER_URL = (args.llama_host or new_config.get("llama_server_host", "http://localhost:8081")).rstrip("/") + "/v1"
-    current_module.REQUEST_TIMEOUT = new_config.get("request_timeout", 1800000)
     # CLI_MODEL: разрешаем алиас в реальное имя модели
     _alias = args.model or new_config.get("default_model")
     _models_dict = new_config.get("models", {})
@@ -170,5 +165,5 @@ def switch_config(config_name: str) -> bool:
     # Обновляем args.config чтобы importlib.reload(config) тоже подхватил
     if hasattr(current_module.args, 'config'):
         current_module.args.config = config_str
-    
+
     return True

bot/llama_server.py

@@ -283,7 +283,6 @@ async def do_restart(
     ready = await wait_for_llama_server(model_alias=alias)
 
     if ready:
-        await vk_client.send_message(user_id, f"✅ Модель {alias} загружена и готова!")
         logger.info(f"Model {alias} loaded successfully")
     else:
         await vk_client.send_message(

bot/main.py

@@ -112,7 +112,7 @@ async def main():
         workdir = Path(session_mgr.session_workdir[first_session_id])
         logger.info(f"Restored workdir from session {first_session_id}: {workdir}")
 
-    opencode_process = OpenCodeProcess(model=bot_config.CLI_MODEL, provider_url=bot_config.PROVIDER_URL, workdir=workdir, timeout=bot_config.REQUEST_TIMEOUT)
+    opencode_process = OpenCodeProcess(model=bot_config.CLI_MODEL, provider_url=bot_config.PROVIDER_URL, workdir=workdir)
     logger.info(f"OpenCodeProcess created with workdir={opencode_process.workdir}")
     await opencode_process.start()
 

bot/models.py

@@ -24,7 +24,4 @@ def model_to_api_format(model: str) -> dict:
         return {}
     if isinstance(model, dict):
         return {"model": model}
-    if "/" in model:
-        providerID, model_id = model.split("/", 1)
-        return {"model": {"id": model_id, "providerID": providerID}}
     return {"model": {"id": model, "providerID": "cli"}}

bot/opencode_process.py

@@ -2,33 +2,90 @@
 Управление процессом OpenCode (lildax)
 """
 import asyncio
+import json
 import os
 import subprocess
 import socket
 from pathlib import Path
 
-from config import OPENCODE_BIN, PROVIDER_URL, CLI_MODEL, REQUEST_TIMEOUT
+from config import OPENCODE_BIN, OPENCODE_CONFIG_PATH, PROVIDER_URL, CLI_MODEL, MCP_SERVERS
 from logging_config import logger
 
 
+def sync_mcp_to_lildax_config() -> bool:
+    """Синхронизирует MCP сервера из bot/config.json в lildax config.
+
+    Читает mcp_servers из bot/config.json и обновляет секцию 'mcp'
+    в ~/.config/lildax/config.json.
+
+    Returns:
+        True если успешно, иначе False
+    """
+    try:
+        # Путь к lildax config (OPENCODE_CONFIG_PATH)
+        lildax_config_path = Path(OPENCODE_CONFIG_PATH).expanduser()
+
+        if not MCP_SERVERS:
+            logger.debug("No mcp_servers in bot config, skipping sync")
+            return True
+
+        # Читаем текущий lildax config
+        try:
+            with open(lildax_config_path, "r", encoding="utf-8") as f:
+                lildax_config = json.load(f)
+        except FileNotFoundError:
+            logger.warning(f"Lildax config not found at {lildax_config_path}, creating new")
+            lildax_config = {}
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in lildax config: {e}")
+            return False
+
+        # Обновляем или создаём секцию mcp
+        if "mcp" not in lildax_config:
+            lildax_config["mcp"] = {}
+
+        # Формат: { "server-name": { "type": "local", "command": [...], "enabled": true } }
+        for server_name, server_config in MCP_SERVERS.items():
+            if isinstance(server_config, dict) and server_config.get("enabled", True):
+                lildax_config["mcp"][server_name] = {
+                    "type": server_config.get("type", "local"),
+                    "command": server_config.get("command", []),
+                }
+                if "cwd" in server_config:
+                    lildax_config["mcp"][server_name]["cwd"] = server_config["cwd"]
+                if "environment" in server_config:
+                    lildax_config["mcp"][server_name]["environment"] = server_config["environment"]
+
+        # Сохраняем обновлённый config
+        lildax_config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(lildax_config_path, "w", encoding="utf-8") as f:
+            json.dump(lildax_config, f, indent=2, ensure_ascii=False)
+
+        logger.info(f"Synced {len(MCP_SERVERS)} MCP servers to {lildax_config_path}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to sync MCP to lildax config: {e}")
+        return False
+
+
 class OpenCodeProcess:
     """Управление процессом lildax serve."""
 
-    def __init__(self, model: str = None, provider_url: str = None, workdir: Path = None, timeout: int = None):
+    def __init__(self, model: str = None, provider_url: str = None, workdir: Path = None):
         self.logger = logger
         self.process = None
         self.opencode_port = 4098
         self.model = model or CLI_MODEL
         self.provider_url = provider_url or PROVIDER_URL
-        self.timeout = timeout or REQUEST_TIMEOUT
         self.workdir = workdir or Path.cwd()
         self.logger.debug(
-            f"OpenCodeProcess initialized: workdir={self.workdir}, model={self.model}, provider_url={self.provider_url}, timeout={self.timeout}"
+            f"OpenCodeProcess initialized: workdir={self.workdir}, model={self.model}, provider_url={self.provider_url}"
         )
 
     def _remove_password_file(self):
         """Удаляет файл password, чтобы lildax не требовал аутентификацию."""
-        password_file = Path.home() / ".local" / "state" / "opencode" / "password"
+        password_file = Path.home() / ".local" / "state" / "lildax" / "password"
         if password_file.exists():
             try:
                 os.remove(password_file)
@@ -42,8 +99,6 @@ def _build_args(self) -> list[str]:
             args.extend(["--provider-url", self.provider_url])
         if self.model:
             args.extend(["--model", self.model])
-        if self.timeout:
-            args.extend(["--timeout", str(self.timeout)])
         return args
 
     async def start(self):
@@ -66,6 +121,9 @@ async def start(self):
                 break
             await asyncio.sleep(0.5)
 
+        # Синхронизируем MCP сервера в lildax config (после убийства, до старта)
+        sync_mcp_to_lildax_config()
+
         # Логирование в файл для отладки
         log_file_path = f"/tmp/lildax_{self.opencode_port}.log"
         log_file = None
@@ -103,13 +161,11 @@ async def start(self):
             if log_file:
                 log_file.close()
 
-    async def restart(self, model: str = None, provider_url: str = None, workdir: Path = None, timeout: int = None):
+    async def restart(self, model: str = None, provider_url: str = None, workdir: Path = None):
         if model:
             self.model = model
         if provider_url:
             self.provider_url = provider_url
-        if timeout:
-            self.timeout = timeout
         if workdir:
             self.logger.info(
                 f"restart: updating workdir from {self.workdir} to {workdir}"

bot/session_manager.py

@@ -18,7 +18,6 @@ class SessionManager:
     def __init__(self, file_path: Path):
         self.file_path = file_path
         self.sessions: Dict[int, str] = {}
-        self.seen_messages: Dict[str, set] = {}
         self.grant_mode: Dict[str, bool] = {}
         self.session_workdir: Dict[str, str] = {}  # session_id -> workdir path
         self.child_sessions: Dict[str, str] = {}  # child_session_id -> parent_session_id
@@ -29,9 +28,6 @@ def _load(self) -> None:
             with open(self.file_path, "r", encoding="utf-8") as f:
                 data = json.load(f)
                 self.sessions = {int(k): v for k, v in data.get("sessions", {}).items()}
-                self.seen_messages = {
-                    sid: set(ids) for sid, ids in data.get("seen_messages", {}).items()
-                }
                 self.grant_mode = {
                     sid: bool(val) for sid, val in data.get("grant_mode", {}).items()
                 }
@@ -43,17 +39,13 @@ def _load(self) -> None:
                 }
         except (FileNotFoundError, json.JSONDecodeError):
             self.sessions = {}
-            self.seen_messages = {}
             self.grant_mode = {}
             self.session_workdir = {}
             self.child_sessions = {}
 
     def _save(self) -> None:
         data = {
             "sessions": {str(k): v for k, v in self.sessions.items()},
-            "seen_messages": {
-                sid: list(ids) for sid, ids in self.seen_messages.items()
-            },
             "grant_mode": dict(self.grant_mode),
             "session_workdir": dict(self.session_workdir),
             "child_sessions": dict(self.child_sessions),
@@ -73,8 +65,6 @@ async def get_or_create(self, user_id: int) -> str:
                 # API возвращает {data: {id: ...}}
                 session_id = resp_data.get("data", resp_data).get("id")
                 self.sessions[user_id] = session_id
-                if session_id not in self.seen_messages:
-                    self.seen_messages[session_id] = set()
                 if session_id not in self.grant_mode:
                     self.grant_mode[session_id] = False
                 self._save()
@@ -83,22 +73,10 @@ async def get_or_create(self, user_id: int) -> str:
                 )
                 return session_id
 
-    def get_seen_messages(self, session_id: str) -> set:
-        return self.seen_messages.get(session_id, set())
-
-    def add_seen_message(self, session_id: str, message_id: str):
-        if session_id not in self.seen_messages:
-            self.seen_messages[session_id] = set()
-        self.seen_messages[session_id].add(message_id)
-        logger.debug(f"Saved seen message {message_id} to file for session {session_id}")
-        self._save()
-
     def remove(self, user_id: int):
         if user_id in self.sessions:
             session_id = self.sessions[user_id]
             del self.sessions[user_id]
-            if session_id in self.seen_messages:
-                del self.seen_messages[session_id]
             if session_id in self.grant_mode:
                 del self.grant_mode[session_id]
             if session_id in self.session_workdir:
@@ -141,8 +119,6 @@ def remove_session(self, user_id: int):
         if user_id in self.sessions:
             session_id = self.sessions[user_id]
             del self.sessions[user_id]
-            if session_id in self.seen_messages:
-                del self.seen_messages[session_id]
             if session_id in self.grant_mode:
                 del self.grant_mode[session_id]
             if session_id in self.session_workdir: