fix(itchat): correct group/private message handling and sender resolution

- filter the bot's own messages to prevent reply loops
- use startswith('@@') for group detection
- use ActualUserName as stable GroupMember id
- fill Friend.remark from RemarkName
- strip @mention prefix with a regex

docs/multi-tenant/implementation-decisions.md

@@ -103,11 +103,11 @@ This log records implementation choices made while delivering the Workspace arch
 - Decision: New Core JWTs require `iss=langbot-core`, an audience derived from the immutable instance UUID, and an expiry. Legacy community tokens are accepted only when they have the historical issuer, carry no audience, and the active policy is the OSS singleton policy.
 - Reason: A token issued by one instance must not authenticate against another instance that happens to share a secret, and a compatibility decoder must not become an alternate path around the SaaS trust boundary.
 
-### Runtime control transports authenticate before protocol dispatch
+### Runtime control transports support opt-in shared-secret authentication
 
-- Decision: External Plugin Runtime and Box WebSocket control channels require independent strong shared secrets in handshake headers. Locally managed child processes receive ephemeral secrets through their environment; secrets are not placed in URLs, process arguments, request payloads, or logs. Box additionally binds the first authenticated control channel to one trusted instance. Plugin Runtime debug and control credentials remain separate.
-- Reason: Workspace context inside an RPC payload is not trustworthy until the transport peer itself is authenticated. Separating control and debug credentials also limits accidental privilege reuse.
-- Deployment consequence: Docker Compose and Kubernetes wire one shared secret to each host/runtime pair. An empty external-runtime secret fails startup instead of silently exposing an unauthenticated socket.
+- Decision: OSS external Plugin Runtime and Box WebSocket control channels preserve tokenless standalone compatibility when the corresponding control token is unset. When a Runtime configures a token, it validates the independent shared secret in the handshake before protocol dispatch. Locally managed child processes still receive ephemeral secrets through their environment; secrets are not placed in URLs, process arguments, request payloads, or logs. Box additionally pins the first control channel to one declared instance identity. Plugin Runtime debug and control credentials remain separate.
+- Reason: Local OSS development must remain backward compatible, while exposed or shared Runtime endpoints can opt into transport authentication. Separating control and debug credentials also limits accidental privilege reuse.
+- Deployment consequence: Docker Compose and Kubernetes should wire one strong shared secret to each host/runtime pair. Both sides must use the same value for protection to be effective; a Runtime configured with a token rejects clients that omit it or send a different value.
 
 ### Dashboard WebSocket sessions are tenant runtime objects
 

pyproject.toml

@@ -22,6 +22,7 @@ dependencies = [
     "discord-py>=2.5.2",
     "pynacl>=1.5.0", # Required for Discord voice support
     "gewechat-client>=0.1.5",
+    "itchat-uos>=1.5.0.dev",
     "lark-oapi>=1.5.5",
     "mcp>=1.25.0,<2.0.0",
     "nakuru-project-idk>=0.0.2.1",
@@ -71,7 +72,7 @@ dependencies = [
     "chromadb>=1.0.0,<2.0.0",
     "qdrant-client (>=1.15.1,<2.0.0)",
     "pyseekdb==1.1.0.post3",
-    "langbot-plugin @ git+https://github.com/langbot-app/langbot-plugin-sdk.git@9d216208cdfb41f0cb7fcb64632e2a46816d6dc6",
+    "langbot-plugin @ git+https://github.com/langbot-app/langbot-plugin-sdk.git@7b559da430a50f80a7d30c9d3d66f088503ddbb3",
     "asyncpg>=0.30.0",
     "line-bot-sdk>=3.19.0",
     "matrix-nio>=0.25.2",

skills/skills/langbot-deploy/SKILL.md

@@ -27,10 +27,11 @@ The `all` / `box` profile starts three services:
 - `langbot_box` — Box sandbox runtime (`:5410`). Uses the host Docker socket to
   spawn sandbox containers, so the **Box root host path and in-container path
   must be identical** (`BOX__LOCAL__HOST_ROOT=${LANGBOT_BOX_ROOT:-${PWD}/data/box}`).
-  Its RPC and managed-process relay require a shared
-  `LANGBOT_BOX_CONTROL_TOKEN` (at least 32 non-whitespace characters) in both
-  the LangBot and Box containers. Generate it once with `openssl rand -hex 32`;
-  never put it in `box.runtime.endpoint` or commit it to config.
+  OSS allows its RPC and managed-process relay to run without a token when both
+  sides leave `LANGBOT_BOX_CONTROL_TOKEN` unset. For an exposed endpoint, set
+  the same value of at least 32 non-whitespace characters in both the LangBot
+  and Box containers. Generate it once with `openssl rand -hex 32`; never put
+  it in `box.runtime.endpoint` or commit it to config.
 
 A Compose deployment may optionally set
 `LANGBOT_PLUGIN_RUNTIME_CONTROL_TOKEN` on both `langbot` and

skills/skills/langbot-space-ops/SKILL.md

@@ -6,7 +6,8 @@ description: Browse and search the LangBot Space marketplaces (plugins, MCP serv
 # LangBot Space MCP Operations
 
 LangBot Space (space.langbot.app) exposes an **MCP server** so user-facing AI
-agents can browse and search the marketplaces (plugins, MCP servers, skills).
+agents can browse and search the marketplaces (plugins, MCP servers, skills) and
+rank live models for automated setup.
 
 ## Endpoint
 
@@ -46,10 +47,12 @@ Authorization: Bearer lbpat_...uests without a valid PAT get `401 Unauthorized`.
 | `list_plugins` / `search_plugins` / `get_plugin` | Plugin marketplace |
 | `list_mcp_servers` / `search_mcp_servers` / `get_mcp_server` | MCP-server marketplace |
 | `list_skills` / `search_skills` / `get_skill` | Skill marketplace |
+| `select_models` | Live best-first model list for setup wizards; optional `category` filter |
 
 `list_*` and `search_*` are paged (`page`, `page_size`). `get_*` takes
 `author` + `name`. The tool surface mirrors the REST endpoints under
-`/api/v1/marketplace/*` and is read/browse only.
+`/api/v1/marketplace/*`; `select_models` mirrors `/api/v1/models/selection`.
+All tools are read-only.
 
 ## How to use
 
@@ -58,12 +61,16 @@ Authorization: Bearer lbpat_...uests without a valid PAT get `401 Unauthorized`.
 3. Use `search_plugins` / `search_mcp_servers` / `search_skills` to find items,
    then `get_*` for details (e.g. to obtain author/name for installation in
    LangBot itself).
+4. For automatic local-agent setup, call `select_models` (optionally with
+   `category`) and choose the first compatible item. Ordering is latest probe
+   state (available, unprobed, unavailable), then Space recommendation. Each
+   item includes `availability.up`, `last_probed_at`, latency, and HTTP status.
 
 ## Implementation & maintenance (for Space developers)
 
 - Server: `internal/controller/mcp/server.go` (official Go MCP SDK
   `github.com/modelcontextprotocol/go-sdk`). Tools call the service layer
-  (`PluginService`, `MCPService`, `SkillService`) directly.
+  (`PluginService`, `MCPService`, `SkillService`, `ModelStatusService`) directly.
 - Mount: `internal/controller/api.go` at `/mcp` and `/mcp/*any`.
 - Auth: PAT via `AccountService.ValidatePersonalAccessToken`.
 - Docs: `docs/MCP_SERVER.md`.

src/langbot/pkg/api/http/controller/groups/platform/adapters.py

@@ -1,6 +1,7 @@
 import asyncio
 import dataclasses
 import mimetypes
+import os
 
 import quart
 
@@ -1133,3 +1134,224 @@ class AdaptersRouterGroup(group.RouterGroup):
             if session and session.get('task') and not session['task'].done():
                 session['task'].cancel()
             return self.success(data={})
+
+        # -----------------------------------------------------------------------
+        # Itchat WeChat QR Code Login
+        # -----------------------------------------------------------------------
+
+        _itchat_login_sessions: dict = {}
+        _ITCHAT_SESSION_TTL = 600  # 10 minutes (allows multiple QR regenerations)
+
+        def _cleanup_expired_itchat_sessions():
+            import time
+
+            now = time.time()
+            expired = [
+                sid for sid, s in _itchat_login_sessions.items() if now - s.get('created_at', 0) > _ITCHAT_SESSION_TTL
+            ]
+            for sid in expired:
+                session = _itchat_login_sessions.pop(sid, None)
+                if session:
+                    core = session.get('core')
+                    if core:
+                        try:
+                            core.alive = False
+                            core.isLogging = False
+                        except Exception:
+                            pass
+
+        @self.route('/itchat/login', methods=['POST'])
+        async def _() -> str:
+            """Start itchat WeChat QR code login. Returns session_id + QR code data URL."""
+            import uuid
+            import time
+            import base64
+            import threading
+
+            _cleanup_expired_itchat_sessions()
+
+            session_id = str(uuid.uuid4())
+            loop = asyncio.get_running_loop()
+            status_dir = os.path.join('data', 'itchat')
+            os.makedirs(status_dir, exist_ok=True)
+            qr_path = os.path.join(status_dir, f'{session_id}-QR.png')
+
+            session = {
+                'status': 'pending',
+                'qr_data_url': None,
+                'expire_at': None,
+                'nickname': None,
+                'error': None,
+                'created_at': time.time(),
+                'thread': None,
+                'logged_in': threading.Event(),
+                'core': None,
+            }
+            _itchat_login_sessions[session_id] = session
+
+            def _run_itchat_login():
+                try:
+                    from itchat.core import Core
+                    from itchat.content import TEXT as _TEXT
+                    from langbot.pkg.platform.sources.itchat import ItchatAdapter
+
+                    for f in (qr_path,):
+                        try:
+                            os.remove(f)
+                        except OSError:
+                            pass
+
+                    _core = Core()
+                    session['core'] = _core
+
+                    def on_login():
+                        try:
+                            _core.get_friends(update=True)
+                            user_info = _core.loginInfo.get('User', {})
+                            nick = ItchatAdapter._get_obj_value(user_info, 'NickName', 'unknown')
+                            wxid = ItchatAdapter._get_obj_value(user_info, 'UserName')
+                        except Exception:
+                            nick = 'unknown'
+                            wxid = ''
+                        session['nickname'] = nick
+                        session['wxid'] = wxid
+                        print(f'[itchat-login] Login success: {nick}', flush=True)
+                        # Dump login status so the adapter can hot-reload it
+                        try:
+                            if not wxid:
+                                raise ValueError('Unable to detect WeChat wxid after login')
+                            account_status_path = ItchatAdapter.login_status_path_for_account(wxid)
+                            _core.dump_login_status(account_status_path)
+                            session['login_status_path'] = account_status_path
+                            session['status'] = 'success'
+                            print(f'[itchat-login] Session saved to {account_status_path}', flush=True)
+                        except Exception as e:
+                            session['status'] = 'error'
+                            session['error'] = str(e)
+                            print(f'[itchat-login] Failed to save session: {e}', flush=True)
+                        finally:
+                            session['logged_in'].set()
+                        # Stop the message loop - we only needed the session for QR login
+                        _core.alive = False
+
+                    def on_qr(**kwargs):
+                        qr_bytes = kwargs.get('qrcode', b'')
+                        status = kwargs.get('status', '')
+                        print(f'[itchat-login] QR callback: status={status}, bytes={len(qr_bytes)}', flush=True)
+                        if status == '200':
+                            return
+                        # Only update QR image on new QR generation (status='0')
+                        # or when status changes to '408' (timeout, QR may refresh)
+                        if qr_bytes and status == '0':
+                            b64 = base64.b64encode(qr_bytes).decode('utf-8')
+
+                            def _update():
+                                session['qr_data_url'] = f'data:image/png;base64,{b64}'
+                                session['expire_at'] = time.time() + 120
+                                session['status'] = 'waiting'
+
+                            loop.call_soon_threadsafe(_update)
+
+                    # Register a dummy text handler
+                    @_core.msg_register([_TEXT])
+                    def _dummy(msg):
+                        pass
+
+                    print('[itchat-login] Step 3: Calling auto_login...', flush=True)
+                    _core.auto_login(
+                        hotReload=False,
+                        loginCallback=on_login,
+                        qrCallback=on_qr,
+                    )
+                    print('[itchat-login] Step 4: auto_login returned, starting run...', flush=True)
+                    _core.run(blockThread=True)
+                    print('[itchat-login] Step 5: run() returned', flush=True)
+                except SystemExit as e:
+                    print(f'[itchat-login] SystemExit: {e}', flush=True)
+                    session['status'] = 'error'
+                    session['error'] = f'itchat exited: {e}'
+                    session['logged_in'].set()
+                except Exception as e:
+                    import traceback
+
+                    print(f'[itchat-login] Exception: {traceback.format_exc()}', flush=True)
+                    session['status'] = 'error'
+                    session['error'] = str(e)
+                    session['logged_in'].set()
+
+            t = threading.Thread(target=_run_itchat_login, daemon=True)
+            t.start()
+            session['thread'] = t
+
+            # Wait for QR code to be ready (max 15 seconds)
+            for _ in range(30):
+                if session['qr_data_url'] or session['error'] or session['status'] == 'success':
+                    break
+                await asyncio.sleep(0.5)
+
+            if session['error']:
+                return self.http_status(502, -1, session['error'])
+
+            if session['status'] == 'success':
+                return self.success(
+                    data={
+                        'session_id': session_id,
+                        'status': 'success',
+                        'nickname': session['nickname'],
+                        'wxid': session.get('wxid', ''),
+                    }
+                )
+
+            if not session['qr_data_url']:
+                session['status'] = 'error'
+                session['error'] = 'Timeout waiting for QR code'
+                return self.http_status(504, -1, 'Timeout waiting for QR code')
+
+            return self.success(
+                data={
+                    'session_id': session_id,
+                    'qr_data_url': session['qr_data_url'],
+                    'expire_at': session['expire_at'],
+                }
+            )
+
+        @self.route('/itchat/login/status/<session_id>', methods=['GET'])
+        async def _(session_id: str) -> str:
+            """Poll itchat login status."""
+            session = _itchat_login_sessions.get(session_id)
+            if not session:
+                return self.http_status(404, -1, 'Session not found')
+
+            data = {
+                'status': session['status'],
+                'qr_data_url': session['qr_data_url'],
+                'expire_at': session['expire_at'],
+            }
+
+            if session['status'] == 'success':
+                data['nickname'] = session.get('nickname', '')
+                data['wxid'] = session.get('wxid', '')
+                _itchat_login_sessions.pop(session_id, None)
+            elif session['status'] == 'error':
+                data['error'] = session['error']
+                _itchat_login_sessions.pop(session_id, None)
+
+            return self.success(data=data)
+
+        @self.route('/itchat/login/<session_id>', methods=['DELETE'])
+        async def _(session_id: str) -> str:
+            """Cancel and clean up an itchat login session."""
+            session = _itchat_login_sessions.pop(session_id, None)
+            if session:
+                core = session.get('core')
+                if core:
+                    try:
+                        core.alive = False
+                        core.isLogging = False
+                    except Exception:
+                        pass
+                thread = session.get('thread')
+                if thread and thread.is_alive():
+                    # Thread is daemon, will die with the process
+                    pass
+            return self.success(data={})

src/langbot/pkg/api/http/controller/groups/platform/bots.py

@@ -113,24 +113,6 @@ class BotsRouterGroup(group.RouterGroup):
             )
             return self.success(data={'sent': True})
 
-        @self.route(
-            '/<bot_uuid>/test-inbound',
-            methods=['POST'],
-            auth_type=group.AuthType.USER_TOKEN,
-            permission=Permission.RESOURCE_MANAGE,
-        )
-        async def _(bot_uuid: str, request_context: RequestContext) -> str:
-            json_data = await quart.request.get_json(silent=True) or {}
-            try:
-                result = await self.ap.bot_service.send_http_bot_test_message(
-                    request_context,
-                    bot_uuid,
-                    str(json_data.get('message') or ''),
-                )
-            except ValueError as exc:
-                return self.http_status(400, -1, str(exc))
-            return self.success(data=result)
-
         @self.route(
             '/<bot_uuid>/admins',
             methods=['GET'],

src/langbot/pkg/api/http/controller/groups/plugins.py

@@ -398,7 +398,16 @@ class PluginsRouterGroup(group.RouterGroup):
 
             # Get debug URL from config
             plugin_config = self.ap.instance_config.data.get('plugin', {})
-            debug_url = plugin_config.get('display_plugin_debug_url', 'http://localhost:5401')
+            debug_url = plugin_config.get(
+                'display_plugin_debug_url',
+                'ws://localhost:5401/plugin/debug/ws',
+            )
+            parsed_debug_url = urlparse(debug_url)
+            if parsed_debug_url.scheme in {'http', 'https'}:
+                debug_url = parsed_debug_url._replace(
+                    scheme='wss' if parsed_debug_url.scheme == 'https' else 'ws',
+                    path=parsed_debug_url.path or '/plugin/debug/ws',
+                ).geturl()
 
             return self.success(
                 data={

src/langbot/pkg/api/http/controller/groups/system.py

@@ -206,20 +206,6 @@ class SystemRouterGroup(group.RouterGroup):
 
             return self.success(data={})
 
-        @self.route(
-            '/wizard/recommended-model',
-            methods=['GET'],
-            auth_type=group.AuthType.USER_TOKEN,
-            permission=Permission.RESOURCE_MANAGE,
-        )
-        async def _(request_context: RequestContext) -> str:
-            """Resolve Space's best available chat model to this Workspace."""
-            try:
-                model = await self.ap.space_service.get_recommended_chat_model(request_context)
-            except ValueError as exc:
-                return self.http_status(503, -1, str(exc))
-            return self.success(data=model)
-
         @self.route(
             '/tasks',
             methods=['GET'],

src/langbot/pkg/api/http/service/bot.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import uuid
-import json
 import sqlalchemy
 
 from ....core import app
@@ -9,8 +8,6 @@ from ....entity.persistence import bot as persistence_bot
 from ....entity.persistence import pipeline as persistence_pipeline
 from ....workspace.errors import WorkspaceNotFoundError
 from .tenant import TenantContext, require_workspace_uuid, scope_statement
-from ....utils import httpclient
-from ....platform.sources import http_bot_signing
 
 
 class BotService:
@@ -72,6 +69,8 @@ class BotService:
         runtime_bot = await self.ap.platform_mgr.get_bot_by_uuid(context, bot_uuid)
         if runtime_bot is not None:
             adapter_runtime_values['bot_account_id'] = runtime_bot.adapter.bot_account_id
+            if hasattr(runtime_bot.adapter, 'get_runtime_status'):
+                adapter_runtime_values['runtime_status'] = runtime_bot.adapter.get_runtime_status()
 
         # Webhook URL for unified webhook adapters (independent of bot running state)
         if persistence_bot['adapter'] in [
@@ -83,7 +82,6 @@ class BotService:
             'wecomcs',
             'LINE',
             'lark',
-            'http_bot',
         ]:
             webhook_prefix = self.ap.instance_config.data['api'].get('webhook_prefix', 'http://127.0.0.1:5300')
             extra_webhook_prefix = self.ap.instance_config.data['api'].get('extra_webhook_prefix', '')
@@ -220,53 +218,6 @@ class BotService:
 
         return [log.to_json() for log in logs], total_count
 
-    async def send_http_bot_test_message(
-        self,
-        context: TenantContext,
-        bot_uuid: str,
-        message: str,
-    ) -> dict:
-        """Send a signed test message through the HTTP Bot public ingress."""
-        bot = await self.get_bot(context, bot_uuid, include_secret=True)
-        if bot is None:
-            raise WorkspaceNotFoundError('Bot not found')
-        if bot.get('adapter') != 'http_bot':
-            raise ValueError('Inbound test is only available for HTTP Bot')
-        if not bot.get('enable'):
-            raise ValueError('Bot must be enabled before sending a test message')
-
-        text = message.strip()
-        if not text or len(text) > 2000:
-            raise ValueError('Test message must contain 1 to 2000 characters')
-
-        payload = {
-            'session_id': f'wizard-{uuid.uuid4().hex}',
-            'sender': {'id': 'wizard-user', 'name': 'Wizard Test'},
-            'message': [{'type': 'Plain', 'text': text}],
-        }
-        body = json.dumps(payload, ensure_ascii=False, separators=(',', ':')).encode()
-        config = bot.get('adapter_config') or {}
-        headers = {'Content-Type': 'application/json'}
-        if config.get('signature_required', True):
-            secret = str(config.get('inbound_secret') or '')
-            if not secret:
-                raise ValueError('HTTP Bot inbound signing secret is required')
-            timestamp, signature = http_bot_signing.sign(secret, body)
-            headers[http_bot_signing.HEADER_TIMESTAMP] = timestamp
-            headers[http_bot_signing.HEADER_SIGNATURE] = signature
-
-        port = int(self.ap.instance_config.data.get('api', {}).get('port', 5300))
-        session = httpclient.get_session()
-        async with session.post(
-            f'http://127.0.0.1:{port}/bots/{bot_uuid}',
-            data=body,
-            headers=headers,
-        ) as response:
-            result = await httpclient.read_json_limited(response)
-            if response.status not in {200, 202}:
-                raise ValueError(result.get('msg') or f'HTTP Bot test failed with status {response.status}')
-            return result.get('data') or {}
-
     async def send_message(
         self,
         context: TenantContext,

src/langbot/pkg/api/http/service/space.py

@@ -11,9 +11,6 @@ import sqlalchemy
 from ....core import app
 from ....entity.persistence import user
 from ....entity.dto.space_model import SpaceModel
-from ....entity.dto.space_model import SpaceModelSelection
-from ....entity.persistence import model as persistence_model
-from ....cloud.model_catalog import LANGBOT_MODELS_PROVIDER_REQUESTER
 
 
 _CREDITS_CACHE_TTL_SECONDS = 60
@@ -241,79 +238,3 @@ class SpaceService:
                 raise ValueError(f'Failed to get models: {data.get("msg")}')
             models_data = data.get('data', {}).get('models', [])
             return [SpaceModel.model_validate(model_dict) for model_dict in models_data]
-
-    async def get_model_selection(self, category: str) -> typing.List[SpaceModelSelection]:
-        """Return Space models in the availability-ranked selection order."""
-        space_url = self._get_space_config()['url']
-        session = httpclient.get_session()
-        async with session.get(
-            f'{space_url}/api/v1/models/selection',
-            params={'category': category},
-        ) as response:
-            if response.status != 200:
-                error = await httpclient.read_text_limited(response)
-                raise ValueError(f'Failed to get model selection: {error}')
-            payload = await httpclient.read_json_limited(response)
-            if payload.get('code') != 0:
-                raise ValueError(f'Failed to get model selection: {payload.get("msg")}')
-
-            data = payload.get('data', [])
-            if isinstance(data, dict):
-                data = data.get('models', data.get('items', []))
-            if not isinstance(data, list):
-                raise ValueError('Failed to get model selection: invalid response')
-
-            models = []
-            for selection in data:
-                if isinstance(selection, dict) and isinstance(selection.get('model'), dict):
-                    models.append(selection['model'])
-                else:
-                    models.append(selection)
-            return [SpaceModelSelection.model_validate(model) for model in models]
-
-    async def get_recommended_chat_model(self, context: typing.Any) -> dict:
-        """Resolve Space's first ranked chat model to a local Workspace model."""
-        selection = await self.get_model_selection('chat')
-        if not selection:
-            raise ValueError('No recommended chat model is available')
-        recommended = selection[0]
-
-        async def find_local_model():
-            result = await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.select(persistence_model.LLMModel)
-                .join(
-                    persistence_model.ModelProvider,
-                    sqlalchemy.and_(
-                        persistence_model.ModelProvider.workspace_uuid
-                        == persistence_model.LLMModel.workspace_uuid,
-                        persistence_model.ModelProvider.uuid == persistence_model.LLMModel.provider_uuid,
-                    ),
-                )
-                .where(
-                    persistence_model.LLMModel.workspace_uuid == context.workspace_uuid,
-                    persistence_model.ModelProvider.requester == LANGBOT_MODELS_PROVIDER_REQUESTER,
-                    sqlalchemy.or_(
-                        persistence_model.LLMModel.uuid == recommended.uuid,
-                        persistence_model.LLMModel.name == recommended.model_id,
-                    ),
-                )
-            )
-            return result.first()
-
-        local_model = await find_local_model()
-        if local_model is None:
-            # OSS synchronizes the public catalog locally. Refresh once in case
-            # the recommendation was published after this process started.
-            from ..context import ExecutionContext
-
-            try:
-                await self.ap.model_mgr.sync_new_models_from_space(
-                    ExecutionContext.from_request(context)
-                )
-            except Exception:
-                pass
-            local_model = await find_local_model()
-
-        if local_model is None:
-            raise ValueError('Recommended chat model is not available in this Workspace')
-        return {'uuid': local_model.uuid, 'name': local_model.name}

src/langbot/pkg/box/connector.py

@@ -367,6 +367,8 @@ class BoxRuntimeConnector(ManagedRuntimeConnector):
     def _ensure_control_token(self, *, allow_generate: bool) -> str:
         if not self._control_token and allow_generate:
             self._control_token = secrets.token_urlsafe(48)
+        if not self._control_token:
+            return ''
         try:
             self._control_token = validate_control_token(self._control_token)
         except ValueError as exc:
@@ -376,19 +378,19 @@ class BoxRuntimeConnector(ManagedRuntimeConnector):
         return self._control_token
 
     def get_control_headers(self) -> dict[str, str]:
-        """Headers for the instance-authenticated RPC control handshake."""
+        """Return instance-scoped RPC headers and the optional shared secret."""
 
         self._ensure_control_token(allow_generate=False)
-        return {
-            BOX_CONTROL_TOKEN_HEADER: self._control_token,
-            BOX_INSTANCE_HEADER: self._trusted_instance_uuid,
-        }
+        headers = {BOX_INSTANCE_HEADER: self._trusted_instance_uuid}
+        if self._control_token:
+            headers[BOX_CONTROL_TOKEN_HEADER] = self._control_token
+        return headers
 
     def get_relay_headers(
         self,
         action_context: ActionContext,
     ) -> dict[str, str]:
-        """Return authenticated, placement-scoped relay handshake headers."""
+        """Return instance- and placement-scoped relay handshake headers."""
 
         context = ActionContext.model_validate(action_context).without_installation()
         if context.instance_uuid != self._trusted_instance_uuid:

src/langbot/pkg/entity/dto/space_model.py

@@ -47,10 +47,3 @@ class SpaceModel(pydantic.BaseModel):
     status: str
     created_at: str | None = None
     updated_at: str | None = None
-
-
-class SpaceModelSelection(pydantic.BaseModel):
-    """Minimal model identity returned by the ranked selection endpoint."""
-
-    uuid: str
-    model_id: str

src/langbot/pkg/platform/sources/itchat.py

@@ -0,0 +1,771 @@
+"""itchat-uos adapter for LangBot.
+
+Uses the itchat-uos WeChat Web library to integrate personal WeChat accounts
+with LangBot via QR code login.
+
+Reference: https://github.com/littlecodersh/ItChat
+UOS fork: https://github.com/why2lyj/ItChat-uos
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import os
+import re
+import tempfile
+import threading
+import time
+import traceback
+import typing
+
+from itchat.content import TEXT, PICTURE, RECORDING, VIDEO, SHARING
+
+import pydantic
+
+from itchat.core import Core as ItchatCore
+
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
+import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_platform_logger
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+from langbot.pkg.platform.logger import EventLogger
+
+
+class ItchatMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
+    """Converts between LangBot MessageChain and itchat message dicts."""
+
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain,
+    ) -> list[dict]:
+        """LangBot MessageChain -> list of itchat-sendable items.
+
+        Each item is a dict with 'type' and the relevant content field.
+        The adapter's send_message() will call itchat.send() accordingly.
+        """
+        items: list[dict] = []
+        for component in message_chain:
+            if isinstance(component, platform_message.Plain):
+                if component.text:
+                    items.append({'type': 'text', 'content': component.text})
+
+            elif isinstance(component, platform_message.Image):
+                if component.base64:
+                    items.append({'type': 'image', 'base64': component.base64})
+                elif component.url:
+                    items.append({'type': 'image', 'url': component.url})
+
+            elif isinstance(component, platform_message.Voice):
+                if component.base64:
+                    items.append({'type': 'voice', 'base64': component.base64})
+                elif component.url:
+                    items.append({'type': 'voice', 'url': component.url})
+
+            elif isinstance(component, platform_message.File):
+                if component.base64:
+                    items.append({'type': 'file', 'base64': component.base64, 'name': component.name or 'file'})
+                elif component.url:
+                    items.append({'type': 'file', 'url': component.url, 'name': component.name or 'file'})
+
+            elif isinstance(component, platform_message.At):
+                items.append({'type': 'text', 'content': f'@{component.target} '})
+
+            elif isinstance(component, platform_message.AtAll):
+                items.append({'type': 'text', 'content': '@所有人 '})
+
+            elif isinstance(component, platform_message.Forward):
+                for node in component.node_list:
+                    if node.message_chain:
+                        items.extend(await ItchatMessageConverter.yiri2target(node.message_chain))
+
+            elif isinstance(component, platform_message.Unknown):
+                pass  # skip unknown outbound
+
+        return items
+
+    @staticmethod
+    def target2yiri(msg: dict) -> platform_message.MessageChain:
+        """Convert an itchat msg dict to a LangBot MessageChain."""
+        components: list[platform_message.MessageComponent] = []
+        msg_type = msg.get('Type', '')
+
+        if msg_type == 'Text':
+            text = msg.get('Text', '')
+            if text:
+                components.append(platform_message.Plain(text=text))
+
+        elif msg_type == 'Picture':
+            try:
+                temp_dir = tempfile.gettempdir()
+                file_path = os.path.join(temp_dir, msg.get('FileName', 'image.jpg'))
+                msg.download(file_path)
+                if os.path.exists(file_path):
+                    with open(file_path, 'rb') as f:
+                        img_bytes = f.read()
+                    b64 = base64.b64encode(img_bytes).decode('utf-8')
+                    components.append(platform_message.Image(base64=f'data:image/jpeg;base64,{b64}'))
+                    os.remove(file_path)
+                else:
+                    components.append(platform_message.Unknown(text='[Image download failed]'))
+            except Exception:
+                components.append(platform_message.Unknown(text='[Image download failed]'))
+
+        elif msg_type == 'Recording':
+            try:
+                temp_dir = tempfile.gettempdir()
+                file_path = os.path.join(temp_dir, msg.get('FileName', 'voice.mp3'))
+                msg.download(file_path)
+                if os.path.exists(file_path):
+                    with open(file_path, 'rb') as f:
+                        voice_bytes = f.read()
+                    b64 = base64.b64encode(voice_bytes).decode('utf-8')
+                    components.append(platform_message.Voice(base64=b64))
+                    os.remove(file_path)
+                else:
+                    components.append(platform_message.Unknown(text='[Voice download failed]'))
+            except Exception:
+                components.append(platform_message.Unknown(text='[Voice download failed]'))
+
+        elif msg_type == 'Sharing':
+            text = msg.get('Text', '')
+            url = msg.get('Url', '')
+            content = text
+            if url and url not in text:
+                content = f'{text}\n{url}' if text else url
+            if content:
+                components.append(platform_message.Plain(text=content))
+
+        elif msg_type == 'Video':
+            components.append(platform_message.Unknown(text='[Video]'))
+
+        elif msg_type == 'Map':
+            components.append(platform_message.Unknown(text='[Location]'))
+
+        elif msg_type == 'Card':
+            components.append(platform_message.Unknown(text='[Contact Card]'))
+
+        elif msg_type == 'Note':
+            text = msg.get('Text', '')
+            if text:
+                components.append(platform_message.Unknown(text=f'[Note: {text}]'))
+
+        else:
+            text = msg.get('Text', '')
+            if text:
+                components.append(platform_message.Plain(text=text))
+            else:
+                components.append(platform_message.Unknown(text=f'[Unsupported message type: {msg_type}]'))
+
+        return platform_message.MessageChain(components)
+
+
+class ItchatEventConverter(abstract_platform_adapter.AbstractEventConverter):
+    """Converts itchat msg dicts to LangBot events."""
+
+    def __init__(self, adapter_ref: typing.Callable[[], typing.Any]):
+        """adapter_ref is a callable returning the ItchatAdapter instance."""
+        self._get_adapter = adapter_ref
+
+    @staticmethod
+    async def yiri2target(event: platform_events.MessageEvent) -> dict:
+        return event.source_platform_object
+
+    def target2yiri(self, msg: dict) -> typing.Optional[platform_events.MessageEvent]:
+        """Convert itchat msg to FriendMessage or GroupMessage."""
+        from_user = msg.get('FromUserName', '')
+        if not from_user:
+            return None
+
+        adapter = self._get_adapter()
+        bot_account_id = adapter.bot_account_id
+        bot_nickname = adapter._bot_nickname
+
+        # Ignore the bot's own messages to avoid reply loops
+        bot_user_name = getattr(adapter._core.storageClass, 'userName', '')
+        if from_user == bot_account_id or (bot_user_name and from_user == bot_user_name):
+            return None
+
+        message_chain = ItchatMessageConverter.target2yiri(msg)
+        if not message_chain:
+            return None
+
+        # Determine if this is a group message
+        # itchat uses '@@' prefix for chatroom IDs (not '@chatroom' suffix)
+        is_group = from_user.startswith('@@')
+        timestamp = msg.get('CreateTime', 0)
+
+        if is_group:
+            # Actual sender within the group
+            actual_user = msg.get('ActualUserName', '')
+            actual_nick = msg.get('ActualNickName', '') or actual_user
+            if not actual_user:
+                return None
+
+            # Prepend @bot if the bot was mentioned
+            # itchat uses 'IsAt' (capital I, capital A) in produce_group_chat
+            if msg.get('IsAt', False):
+                # Strip @bot_nickname from the text content to avoid LLM confusion
+                if bot_nickname:
+                    at_re = re.compile(re.escape('@' + bot_nickname) + r'[  ]?')
+                    for component in message_chain:
+                        if isinstance(component, platform_message.Plain):
+                            component.text = at_re.sub('', component.text, count=1)
+                            break
+                message_chain = platform_message.MessageChain(
+                    [platform_message.At(target=bot_account_id)] + list(message_chain)
+                )
+
+            # Try to get group display name
+            group_obj = msg.get('User', {})
+            group_name = ''
+            if hasattr(group_obj, 'NickName'):
+                group_name = group_obj.NickName
+            elif isinstance(group_obj, dict):
+                group_name = group_obj.get('NickName', '')
+
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=actual_user,
+                    member_name=actual_nick,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=from_user,
+                        name=group_name or from_user,
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title='',
+                ),
+                message_chain=message_chain,
+                time=timestamp,
+                source_platform_object=msg,
+            )
+        else:
+            # Private / friend message
+            user_obj = msg.get('User', {})
+            sender_nick = adapter._get_obj_value(user_obj, 'NickName')
+            sender_remark = adapter._get_obj_value(user_obj, 'RemarkName')
+
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=from_user,
+                    nickname=sender_nick or from_user,
+                    remark=sender_remark,
+                ),
+                message_chain=message_chain,
+                time=timestamp,
+                source_platform_object=msg,
+            )
+
+
+class ItchatAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
+    """LangBot adapter for itchat-uos (WeChat Web)."""
+
+    name: str = 'itchat'
+
+    config: dict
+    logger: EventLogger
+
+    message_converter: ItchatMessageConverter
+    event_converter: ItchatEventConverter
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ] = {}
+
+    _loop: typing.Optional[asyncio.AbstractEventLoop] = pydantic.PrivateAttr(default=None)
+    _logged_in: typing.Optional[threading.Event] = pydantic.PrivateAttr(default=None)
+    _itchat_thread: typing.Optional[threading.Thread] = pydantic.PrivateAttr(default=None)
+    _core: typing.Optional[ItchatCore] = pydantic.PrivateAttr(default=None)
+    _bot_nickname: str = pydantic.PrivateAttr(default='')
+    _bot_uuid: typing.Optional[str] = pydantic.PrivateAttr(default=None)
+    _startup_error: typing.Optional[str] = pydantic.PrivateAttr(default=None)
+    _connection_status: str = pydantic.PrivateAttr(default='disconnected')
+    _connection_error: str = pydantic.PrivateAttr(default='')
+    _last_connected_at: typing.Optional[float] = pydantic.PrivateAttr(default=None)
+    _last_disconnected_at: typing.Optional[float] = pydantic.PrivateAttr(default=None)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, config: dict, logger: abstract_platform_logger.AbstractEventLogger):
+        message_converter = ItchatMessageConverter()
+        # Event converter needs a reference to self for bot_account_id + nickname
+        event_converter = ItchatEventConverter(adapter_ref=lambda: self)
+
+        super().__init__(
+            config=config,
+            logger=logger,
+            message_converter=message_converter,
+            event_converter=event_converter,
+            listeners={},
+            bot_account_id='',
+        )
+
+        # Initialize private attributes (can't be class-level defaults due to pickle)
+        self._loop = None
+        self._logged_in = threading.Event()
+        self._itchat_thread = None
+        self._core = ItchatCore()
+        self._startup_error = None
+        self._connection_status = 'disconnected'
+        self._connection_error = ''
+        self._last_connected_at = None
+        self._last_disconnected_at = None
+
+    @staticmethod
+    def _get_obj_value(obj: typing.Any, key: str, default: str = '') -> str:
+        if isinstance(obj, dict):
+            return obj.get(key, default) or default
+        return getattr(obj, key, default) or default
+
+    @staticmethod
+    def _safe_status_name(value: str) -> str:
+        cleaned = re.sub(r'[^A-Za-z0-9_.@-]+', '_', value.strip())
+        cleaned = cleaned.strip('._')
+        return cleaned
+
+    @staticmethod
+    def login_status_dir() -> str:
+        path = os.path.join('data', 'itchat')
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    @classmethod
+    def login_status_path_for_account(cls, account_id: str) -> str:
+        safe_name = cls._safe_status_name(account_id)
+        if not safe_name:
+            raise ValueError('account_id is required for itchat login status')
+        filename = f'{safe_name}.pkl'
+        return os.path.join(cls.login_status_dir(), filename)
+
+    def _login_status_path(self) -> str:
+        configured_path = self.config.get('login_status_path', '').strip()
+        if configured_path:
+            return configured_path
+
+        account_id = self.config.get('account_id', '').strip()
+        if not account_id:
+            raise ValueError('account_id is required. Please scan the QR code and save this bot first.')
+
+        return self.login_status_path_for_account(account_id)
+
+    def set_bot_uuid(self, bot_uuid: str):
+        self._bot_uuid = bot_uuid
+
+    def _set_connection_status(self, status: str, error: str = ''):
+        self._connection_status = status
+        self._connection_error = error
+        now = time.time()
+        if status == 'connected':
+            self._last_connected_at = now
+        elif status in {'disconnected', 'error'}:
+            self._last_disconnected_at = now
+
+    def get_runtime_status(self) -> dict:
+        return {
+            'connection_status': self._connection_status,
+            'connection_error': self._connection_error,
+            'last_connected_at': self._last_connected_at,
+            'last_disconnected_at': self._last_disconnected_at,
+        }
+
+    def _on_login(self):
+        """Called by itchat after successful QR code login."""
+        try:
+            # Refresh contacts
+            self._core.get_friends(update=True)
+            self._core.get_chatrooms(update=True)
+
+            # Get bot's own WeChat info from loginInfo['User']
+            user_info = self._core.loginInfo.get('User', {})
+            nick_name = self._get_obj_value(user_info, 'NickName')
+            user_name = self._get_obj_value(user_info, 'UserName')
+
+            # bot_account_id: config override or auto-detected wxid
+            # Used by AtBotRule for matching At.target
+            configured_id = self.config.get('account_id', '').strip()
+            self.bot_account_id = configured_id or user_name or nick_name or 'itchat-bot'
+            # _bot_nickname: config override or auto-detected nickname
+            configured_nick = self.config.get('nickname', '').strip()
+            self._bot_nickname = configured_nick or nick_name
+            self._set_connection_status('connected')
+
+            try:
+                chatrooms = self._core.search_chatrooms() or []
+                group_names = []
+                for c in chatrooms:
+                    name = self._get_obj_value(c, 'NickName', str(c))
+                    if name:
+                        group_names.append(name)
+
+                if group_names:
+                    self._log_sync(
+                        f'itchat login as {nick_name} ({user_name}) | Groups ({len(group_names)}): {", ".join(group_names[:10])}{"..." if len(group_names) > 10 else ""}'
+                    )
+                else:
+                    self._log_sync(f'itchat login as {nick_name} ({user_name}) | No groups found')
+            except Exception as e:
+                self._log_sync(f'itchat login as {nick_name} ({user_name}) | Failed to list groups: {e}', 'warning')
+        except Exception as e:
+            self.bot_account_id = f'WeChat Bot (Error: {e})'
+            self._set_connection_status('error', str(e))
+        finally:
+            self._logged_in.set()
+
+    def _log_sync(self, msg: str, level: str = 'info'):
+        """Thread-safe logging from itchat's sync thread."""
+        try:
+            if self._loop and not self._loop.is_closed():
+                log_fn = getattr(self.logger, level)
+                asyncio.run_coroutine_threadsafe(log_fn(msg), self._loop)
+        except Exception:
+            pass
+
+    def _drain_msglist(self):
+        """Clear all stale messages from the msgList queue.
+
+        itchat's load_login_status fetches old messages via get_msg() and
+        pushes them into msgList. We drain them to avoid replaying history.
+        """
+        try:
+            q = self._core.msgList
+            while True:
+                q.get_nowait()
+        except queue.Empty:
+            pass
+
+    def _on_qr_callback(self, **kwargs):
+        """Called by itchat when QR code is generated or status changes.
+
+        Args:
+            uuid: QR code uuid
+            status: '200' = logged in, '201' = confirmed on phone, '408' = timeout
+            qrcode: raw bytes of the QR code PNG image
+        """
+        status = kwargs.get('status', '')
+        qr_bytes = kwargs.get('qrcode', b'')
+
+        if status == '200':
+            # Login success, no need to show QR
+            return
+
+        # Only show QR on new QR generation (status='0') to avoid spamming
+        if not qr_bytes or status != '0':
+            return
+
+        try:
+            b64 = base64.b64encode(qr_bytes).decode('utf-8')
+            if self._loop and not self._loop.is_closed():
+                asyncio.run_coroutine_threadsafe(
+                    self.logger.info(
+                        'Please scan the QR code to login WeChat:',
+                        images=[platform_message.Image(base64=f'data:image/png;base64,{b64}')],
+                    ),
+                    self._loop,
+                )
+        except Exception:
+            pass
+
+    def _on_exit(self):
+        """Called by itchat on exit."""
+        self._set_connection_status('disconnected')
+        self._log_sync('itchat session exited')
+
+    def _register_itchat_handlers(self):
+        """Register itchat message decorators by re-registering handlers."""
+
+        @self._core.msg_register([TEXT])
+        def _on_text(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([TEXT], isGroupChat=True)
+        def _on_group_text(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([PICTURE])
+        def _on_picture(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([PICTURE], isGroupChat=True)
+        def _on_group_picture(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([RECORDING])
+        def _on_recording(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([RECORDING], isGroupChat=True)
+        def _on_group_recording(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([SHARING])
+        def _on_sharing(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([SHARING], isGroupChat=True)
+        def _on_group_sharing(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([VIDEO])
+        def _on_video(msg):
+            self._dispatch_itchat_message(msg)
+
+        @self._core.msg_register([VIDEO], isGroupChat=True)
+        def _on_group_video(msg):
+            self._dispatch_itchat_message(msg)
+
+    def _dispatch_itchat_message(self, msg: dict):
+        """Bridge itchat callback (sync, in itchat thread) to async listener."""
+        try:
+            event = self.event_converter.target2yiri(msg)
+            if event is None:
+                return
+
+            event_type = type(event)
+            if event_type in self.listeners and self._loop:
+                callback = self.listeners[event_type]
+                asyncio.run_coroutine_threadsafe(
+                    callback(event, self),
+                    self._loop,
+                )
+        except Exception:
+            self._log_sync(f'Error dispatching itchat message: {traceback.format_exc()}', 'error')
+
+    async def send_message(
+        self,
+        target_type: str,
+        target_id: str,
+        message: platform_message.MessageChain,
+    ):
+        """Send a message to a user or group via itchat."""
+        items = await self.message_converter.yiri2target(message)
+        loop = asyncio.get_event_loop()
+
+        # Merge consecutive text items to avoid splitting messages
+        merged = []
+        for item in items:
+            if item['type'] == 'text' and merged and merged[-1]['type'] == 'text':
+                merged[-1]['content'] += item['content']
+            else:
+                merged.append(item)
+
+        for item in merged:
+            try:
+                if item['type'] == 'text':
+                    await loop.run_in_executor(None, self._core.send, item['content'], target_id)
+                elif item['type'] == 'image':
+                    # Save to temp file then send
+                    temp_path = self._save_to_temp(item, 'image')
+                    if temp_path:
+                        await loop.run_in_executor(None, self._core.send, f'@img@{temp_path}', target_id)
+                        self._cleanup_temp(temp_path)
+                elif item['type'] == 'voice':
+                    temp_path = self._save_to_temp(item, 'voice')
+                    if temp_path:
+                        await loop.run_in_executor(None, self._core.send, f'@fil@{temp_path}', target_id)
+                        self._cleanup_temp(temp_path)
+                elif item['type'] == 'file':
+                    temp_path = self._save_to_temp(item, 'file')
+                    if temp_path:
+                        await loop.run_in_executor(None, self._core.send, f'@fil@{temp_path}', target_id)
+                        self._cleanup_temp(temp_path)
+            except Exception:
+                await self.logger.error(f'Failed to send itchat message: {traceback.format_exc()}')
+
+    def _save_to_temp(self, item: dict, prefix: str) -> typing.Optional[str]:
+        """Save base64 or URL data to a temp file and return the path."""
+        try:
+            if 'base64' in item:
+                b64_data = item['base64']
+                # Strip data URI prefix if present
+                if ',' in b64_data:
+                    b64_data = b64_data.split(',', 1)[1]
+                file_bytes = base64.b64decode(b64_data)
+                suffix = '.jpg' if prefix == 'image' else ('.mp3' if prefix == 'voice' else '.bin')
+                fd, temp_path = tempfile.mkstemp(suffix=suffix, prefix=f'itchat_{prefix}_')
+                with os.fdopen(fd, 'wb') as f:
+                    f.write(file_bytes)
+                return temp_path
+            elif 'url' in item:
+                import requests
+
+                resp = requests.get(item['url'], timeout=30)
+                if resp.status_code == 200:
+                    suffix = '.jpg' if prefix == 'image' else ('.mp3' if prefix == 'voice' else '.bin')
+                    fd, temp_path = tempfile.mkstemp(suffix=suffix, prefix=f'itchat_{prefix}_')
+                    with os.fdopen(fd, 'wb') as f:
+                        f.write(resp.content)
+                    return temp_path
+        except Exception:
+            self._log_sync(f'Failed to save temp file: {traceback.format_exc()}', 'error')
+        return None
+
+    def _cleanup_temp(self, path: str):
+        """Remove a temp file."""
+        try:
+            if os.path.exists(path):
+                os.remove(path)
+        except OSError:
+            pass
+
+    def _prepare_reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+    ) -> platform_message.MessageChain:
+        """Render group sender mentions with display names while keeping internal IDs stable."""
+        if not isinstance(message_source, platform_events.GroupMessage):
+            return message
+
+        source_msg = message_source.source_platform_object or {}
+        actual_user = source_msg.get('ActualUserName', '')
+        actual_nick = source_msg.get('ActualNickName', '')
+        if not actual_user or not actual_nick:
+            return message
+
+        components: list[platform_message.MessageComponent] = []
+        changed = False
+        for component in message:
+            if isinstance(component, platform_message.At) and str(component.target) == str(actual_user):
+                components.append(platform_message.Plain(text=f'@{actual_nick} '))
+                changed = True
+            else:
+                components.append(component)
+
+        if not changed:
+            return message
+        return platform_message.MessageChain(components)
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        """Reply to a received message."""
+        source_msg = message_source.source_platform_object
+        if not source_msg:
+            return
+
+        # For group messages, reply to the group; for private, reply to the sender
+        from_user = source_msg.get('FromUserName', '')
+        if not from_user:
+            return
+
+        await self.send_message('friend', from_user, self._prepare_reply_message(message_source, message))
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        self.listeners.pop(event_type, None)
+
+    async def run_async(self):
+        """Start the itchat adapter.
+
+        If an account-specific cached session file exists from a previous QR login,
+        itchat will reuse data/itchat/<account_id>.pkl without requiring a new QR scan.
+        """
+        self._loop = asyncio.get_running_loop()
+        self._logged_in.clear()
+        self._startup_error = None
+        self._set_connection_status('connecting')
+
+        await self.logger.info('itchat adapter starting...')
+
+        # Register itchat message handlers BEFORE calling itchat.auto_login()
+        self._register_itchat_handlers()
+
+        # Run itchat in a daemon thread (it blocks)
+        def _run_itchat():
+            try:
+                status_path = self._login_status_path()
+                if not os.path.exists(status_path):
+                    self._startup_error = (
+                        f'No cached WeChat session found at {status_path}. '
+                        'Please scan the QR code in the bot config page first.'
+                    )
+                    self._set_connection_status('error', self._startup_error)
+                    self._log_sync(self._startup_error, 'error')
+                    self._logged_in.set()
+                    return
+
+                # Use hotReload to reuse the cached session from QR login
+                # If no cache exists, fail fast instead of triggering QR login
+                result = self._core.load_login_status(
+                    status_path, loginCallback=self._on_login, exitCallback=self._on_exit
+                )
+                if result.get('BaseResponse', {}).get('Ret') != 0:
+                    self._startup_error = (
+                        f'Cached WeChat session at {status_path} is invalid. '
+                        'Please scan the QR code in the bot config page again.'
+                    )
+                    self._set_connection_status('error', self._startup_error)
+                    self._log_sync(self._startup_error, 'error')
+                    self._logged_in.set()
+                    return
+
+                # Session loaded, start message loop
+                self._log_sync(f'WeChat session loaded from cache: {status_path}')
+
+                # Clear stale messages that itchat fetched during hot-reload
+                self._drain_msglist()
+
+                self._core.run(blockThread=True)
+                self._set_connection_status('disconnected')
+                self._log_sync('itchat message loop stopped', 'error')
+            except Exception as e:
+                error = f'itchat run error: {e}'
+                self._set_connection_status('error', error)
+                self._log_sync(error, 'error')
+                self._logged_in.set()
+
+        self._itchat_thread = threading.Thread(target=_run_itchat, daemon=True, name='itchat-thread')
+        self._itchat_thread.start()
+
+        # Wait for login to complete (with timeout)
+        await asyncio.get_event_loop().run_in_executor(None, lambda: self._logged_in.wait(timeout=300))
+
+        if not self._logged_in.is_set():
+            raise RuntimeError('itchat login timed out (300s)')
+        if self._startup_error:
+            raise RuntimeError(self._startup_error)
+
+        await self.logger.info(f'itchat adapter running, bot: {self.bot_account_id}')
+
+        # Keep the adapter alive
+        try:
+            await asyncio.Event().wait()
+        except asyncio.CancelledError:
+            pass
+
+    async def kill(self) -> bool:
+        """Stop the itchat adapter."""
+        try:
+            self._core.alive = False
+            self._core.isLogging = False
+        except Exception:
+            pass
+        self._set_connection_status('disconnected')
+        await self.logger.info('itchat adapter stopped')
+        return True

src/langbot/pkg/platform/sources/itchat.yaml

@@ -0,0 +1,75 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: itchat
+  label:
+    en_US: Itchat WeChat
+    zh_Hans: 个人微信 (itchat)
+    zh_Hant: 個人微信 (itchat)
+    ja_JP: 個人WeChat (itchat)
+  description:
+    en_US: Personal WeChat adapter via itchat-uos, supports QR code login and text/image/voice messages
+    zh_Hans: 基于 itchat-uos 的个人微信适配器，扫码登录，支持文本/图片/语音消息
+    zh_Hant: 基於 itchat-uos 的個人微信適配器，掃碼登入，支援文字/圖片/語音訊息
+  icon: wechat.png
+spec:
+  categories:
+    - china
+  help_links:
+    zh: https://github.com/littlecodersh/ItChat
+    en: https://github.com/littlecodersh/ItChat
+  config:
+    - name: qr-login
+      label:
+        en_US: Scan QR Login
+        zh_Hans: 扫码登录
+        zh_Hant: 掃碼登入
+      description:
+        en_US: Scan QR code with WeChat to login. The session will be cached for the adapter to reuse.
+        zh_Hans: 使用微信扫码登录，登录状态将被缓存供适配器复用
+        zh_Hant: 使用微信掃碼登入，登入狀態將被快取供適配器復用
+      type: qr-code-login
+      login_platform: itchat
+      required: false
+    - name: account_id
+      label:
+        en_US: Bot Account ID
+        zh_Hans: 机器人账号标识
+        zh_Hant: 機器人帳號標識
+        ja_JP: ボットアカウントID
+      description:
+        en_US: Auto-filled after QR login with the WeChat wxid. Used for @-mention matching and to load data/itchat/<account_id>.pkl; do not change it to a nickname.
+        zh_Hans: 扫码登录后自动填入微信 wxid。用于群聊 @ 匹配，并加载 data/itchat/<account_id>.pkl；不要改成昵称。
+        zh_Hant: 掃碼登入後自動填入微信 wxid。用於群聊 @ 匹配，並載入 data/itchat/<account_id>.pkl；不要改成暱稱。
+        ja_JP: QRログイン後にWeChatのwxidが自動入力されます。@メンション判定と data/itchat/<account_id>.pkl の読み込みに使うため、ニックネームへ変更しないでください。
+      type: string
+      required: true
+      default: ""
+    - name: nickname
+      label:
+        en_US: Bot Nickname
+        zh_Hans: 机器人昵称
+        zh_Hant: 機器人暱稱
+      description:
+        en_US: The display nickname of the bot. Used to strip @nickname from incoming group messages. Auto-filled after QR login.
+        zh_Hans: 机器人的微信昵称。用于删除群聊消息中的 @昵称 前缀。扫码登录后自动填入
+        zh_Hant: 機器人的微信暱稱。用於刪除群聊訊息中的 @暱稱 前綴。掃碼登入後自動填入
+      type: string
+      required: false
+      default: ""
+    - name: hot_reload
+      label:
+        en_US: Hot Reload
+        zh_Hans: 登录缓存
+        zh_Hant: 登入快取
+      description:
+        en_US: Persist login session to avoid repeated QR code scans on restart
+        zh_Hans: 保存登录状态到本地，重启后无需重新扫码
+        zh_Hant: 儲存登入狀態到本機，重啟後無需重新掃碼
+      type: boolean
+      required: false
+      default: true
+execution:
+  python:
+    path: ./itchat.py
+    attr: ItchatAdapter

src/langbot/pkg/plugin/handler.py

@@ -1962,11 +1962,16 @@ class RuntimeConnectionHandler(handler.Handler):
 
     async def get_debug_info(self, execution_context: ExecutionContext) -> dict[str, Any]:
         """Get debug information including debug key and WS URL"""
+        action_context = ActionContext(
+            instance_uuid=execution_context.instance_uuid,
+            workspace_uuid=execution_context.workspace_uuid,
+            placement_generation=execution_context.placement_generation,
+        )
         result = await self.call_action(
             LangBotToRuntimeAction.GET_DEBUG_INFO,
             {},
             timeout=10,
-            action_context=execution_context,
+            action_context=action_context,
         )
         return result
 

src/langbot/templates/config.yaml

@@ -328,8 +328,9 @@ box:
     enabled: true
     backend: 'local'  # 'local' (Docker/nsjail), 'docker', 'nsjail', or 'e2b'. Can be written via BOX__BACKEND.
     runtime:
-        # External WebSocket runtimes also require LANGBOT_BOX_CONTROL_TOKEN in
-        # both LangBot and Box. Keep the shared secret out of this config file.
+        # LANGBOT_BOX_CONTROL_TOKEN is optional for OSS external WebSocket
+        # runtimes. To protect an exposed endpoint, set the same strong secret
+        # in both LangBot and Box. Keep it out of this config file.
         endpoint: ''  # External Box Runtime base URL, e.g. 'ws://127.0.0.1:5410'. Leave empty for local auto-managed runtime.
     limits:
         max_sessions: 64

src/langbot/templates/embed/widget.js

@@ -1240,14 +1240,6 @@
     // Root container
     var root = document.createElement("div");
     root.id = "langbot-widget-root";
-    root.langbotDestroy = function () {
-      wsDisconnect();
-      if (state.historyReloadTimer) {
-        clearTimeout(state.historyReloadTimer);
-        state.historyReloadTimer = null;
-      }
-      root.remove();
-    };
     document.body.appendChild(root);
 
     var shadow = root.attachShadow({ mode: "open" });

tests/integration/api/test_plugins_security.py

@@ -235,13 +235,24 @@ async def test_debug_key_requires_resource_manage_permission(plugin_security_api
     assert operator_denied.status_code == 403
     assert allowed.status_code == 200
     assert (await allowed.get_json())['data'] == {
-        'debug_url': 'http://localhost:5401',
+        'debug_url': 'ws://localhost:5401/plugin/debug/ws',
         'plugin_debug_key': 'runtime-debug-secret',
         'expires_at': '2026-08-04T12:00:00Z',
     }
     application.plugin_connector.get_debug_info.assert_awaited_once()
 
 
+@pytest.mark.asyncio
+async def test_debug_info_uses_websocket_endpoint_for_legacy_config(plugin_security_api):
+    application, client, _ = plugin_security_api
+    application.instance_config.data['plugin'].pop('display_plugin_debug_url')
+
+    response = await client.get('/api/v1/plugins/debug-info', headers=_headers('manager-token'))
+
+    assert response.status_code == 200
+    assert (await response.get_json())['data']['debug_url'] == 'ws://localhost:5401/plugin/debug/ws'
+
+
 @pytest.mark.asyncio
 async def test_viewer_cannot_read_plugin_runtime_logs(plugin_security_api):
     application, client, _ = plugin_security_api

tests/unit_tests/api/service/test_bot_service.py

@@ -9,9 +9,8 @@ Source: src/langbot/pkg/api/http/service/bot.py
 from __future__ import annotations
 
 import pytest
-from unittest.mock import AsyncMock, MagicMock, Mock, patch
+from unittest.mock import AsyncMock, Mock, patch
 from types import SimpleNamespace
-import json
 import uuid
 
 from langbot.pkg.api.http.service.bot import BotService
@@ -242,29 +241,6 @@ class TestBotServiceGetRuntimeBotInfo:
         assert result['adapter_runtime_values']['webhook_url'] == '/bots/wecom-uuid'
         assert result['adapter_runtime_values']['webhook_full_url'] == 'http://127.0.0.1:5300/bots/wecom-uuid'
 
-    async def test_get_runtime_bot_info_returns_webhook_for_http_bot(self):
-        ap = SimpleNamespace(
-            instance_config=SimpleNamespace(
-                data={'api': {'webhook_prefix': 'https://bot.example.com'}}
-            ),
-            platform_mgr=SimpleNamespace(get_bot_by_uuid=AsyncMock(return_value=None)),
-        )
-        service = BotService(ap)
-        service.get_bot = AsyncMock(
-            return_value={
-                'uuid': 'http-bot-uuid',
-                'name': 'HTTP Bot',
-                'adapter': 'http_bot',
-                'adapter_config': {},
-            }
-        )
-
-        result = await service.get_runtime_bot_info(WORKSPACE_UUID, 'http-bot-uuid')
-
-        assert result['adapter_runtime_values']['webhook_full_url'] == (
-            'https://bot.example.com/bots/http-bot-uuid'
-        )
-
     async def test_get_runtime_bot_info_no_webhook_for_telegram(self):
         """Returns no webhook URL for non-webhook adapters like telegram."""
         # Setup
@@ -629,77 +605,6 @@ class TestBotServiceListEventLogs:
         assert total == 5
 
 
-class TestBotServiceHttpBotInboundTest:
-    async def test_sends_signed_message_through_public_ingress(self):
-        ap = SimpleNamespace(
-            instance_config=SimpleNamespace(data={'api': {'port': 5300}}),
-        )
-        service = BotService(ap)
-        service.get_bot = AsyncMock(
-            return_value={
-                'uuid': 'http-bot-uuid',
-                'adapter': 'http_bot',
-                'adapter_config': {
-                    'signature_required': True,
-                    'inbound_secret': 'test-secret',
-                },
-                'enable': True,
-            }
-        )
-        response = MagicMock(status=202)
-        session = MagicMock()
-        session.post.return_value.__aenter__ = AsyncMock(return_value=response)
-        session.post.return_value.__aexit__ = AsyncMock(return_value=None)
-
-        with (
-            patch('langbot.pkg.api.http.service.bot.httpclient.get_session', return_value=session),
-            patch(
-                'langbot.pkg.api.http.service.bot.httpclient.read_json_limited',
-                new=AsyncMock(
-                    return_value={
-                        'code': 0,
-                        'data': {
-                            'session_id': 'wizard-session',
-                            'accepted_message_id': 'in-message',
-                        },
-                    }
-                ),
-            ),
-        ):
-            result = await service.send_http_bot_test_message(
-                WORKSPACE_UUID,
-                'http-bot-uuid',
-                'hello',
-            )
-
-        assert result['accepted_message_id'] == 'in-message'
-        request = session.post.call_args
-        assert request.args[0] == 'http://127.0.0.1:5300/bots/http-bot-uuid'
-        payload = json.loads(request.kwargs['data'])
-        assert payload['message'] == [{'type': 'Plain', 'text': 'hello'}]
-        headers = request.kwargs['headers']
-        assert headers['X-LB-Timestamp']
-        assert headers['X-LB-Signature'].startswith('sha256=')
-
-    async def test_rejects_non_http_bot(self):
-        service = BotService(SimpleNamespace())
-        service.get_bot = AsyncMock(
-            return_value={
-                'uuid': 'telegram-bot',
-                'adapter': 'telegram',
-                'adapter_config': {},
-                'enable': True,
-            }
-        )
-
-        with pytest.raises(ValueError, match='only available for HTTP Bot'):
-            await service.send_http_bot_test_message(
-                WORKSPACE_UUID,
-                'telegram-bot',
-                'hello',
-            )
-
-
 class TestBotServiceSendMessage:
     """Tests for send_message method."""
 

tests/unit_tests/api/service/test_space_service.py

@@ -820,100 +820,6 @@ class TestSpaceServiceGetModels:
                 await service.get_models()
 
 
-class TestSpaceServiceGetModelSelection:
-    """Tests for availability-ranked model selection."""
-
-    @pytest.mark.parametrize('response_shape', ['direct', 'models-envelope', 'availability-wrapper'])
-    async def test_preserves_selection_order_and_category_query(self, response_shape):
-        ap = SimpleNamespace(instance_config=SimpleNamespace(data={}))
-        service = SpaceService(ap)
-        models = [
-            {
-                'uuid': 'best-model',
-                'model_id': 'best-chat-model',
-                'provider': 'provider-1',
-                'category': 'chat',
-                'status': 'active',
-            },
-            {
-                'uuid': 'fallback-model',
-                'model_id': 'fallback-chat-model',
-                'provider': 'provider-2',
-                'category': 'chat',
-                'status': 'active',
-            },
-        ]
-        if response_shape == 'models-envelope':
-            data = {'models': models}
-        elif response_shape == 'availability-wrapper':
-            data = [
-                {'model': model, 'latency_ms': index + 10, 'http_code': 200}
-                for index, model in enumerate(models)
-            ]
-        else:
-            data = models
-        payload = {'code': 0, 'data': data}
-        mock_response = MagicMock(status=200)
-
-        with (
-            patch('langbot.pkg.api.http.service.space.httpclient.get_session') as get_session,
-            patch(
-                'langbot.pkg.api.http.service.space.httpclient.read_json_limited',
-                new=AsyncMock(return_value=payload),
-            ),
-        ):
-            session = MagicMock()
-            session.get.return_value.__aenter__ = AsyncMock(return_value=mock_response)
-            session.get.return_value.__aexit__ = AsyncMock(return_value=None)
-            get_session.return_value = session
-
-            result = await service.get_model_selection('chat')
-
-        assert [model.uuid for model in result] == ['best-model', 'fallback-model']
-        session.get.assert_called_once_with(
-            'https://space.langbot.app/api/v1/models/selection',
-            params={'category': 'chat'},
-        )
-
-    async def test_recommended_model_uses_first_selection_and_refreshes_once(self):
-        local_model = SimpleNamespace(uuid='local-model-uuid', name='best-chat-model')
-        persistence = SimpleNamespace(
-            execute_async=AsyncMock(
-                side_effect=[
-                    _create_mock_result(first_item=None),
-                    _create_mock_result(first_item=local_model),
-                ]
-            )
-        )
-        model_mgr = SimpleNamespace(sync_new_models_from_space=AsyncMock())
-        ap = SimpleNamespace(
-            instance_config=SimpleNamespace(data={}),
-            persistence_mgr=persistence,
-            model_mgr=model_mgr,
-        )
-        service = SpaceService(ap)
-        service.get_model_selection = AsyncMock(
-            return_value=[
-                SimpleNamespace(uuid='best-upstream-uuid', model_id='best-chat-model'),
-                SimpleNamespace(uuid='fallback-upstream-uuid', model_id='fallback-chat-model'),
-            ]
-        )
-        context = SimpleNamespace(
-            instance_uuid='instance',
-            workspace_uuid='workspace',
-            placement_generation=1,
-            principal=SimpleNamespace(),
-            entitlement_revision=0,
-        )
-
-        result = await service.get_recommended_chat_model(context)
-
-        assert result == {'uuid': 'local-model-uuid', 'name': 'best-chat-model'}
-        service.get_model_selection.assert_awaited_once_with('chat')
-        model_mgr.sync_new_models_from_space.assert_awaited_once()
-        assert persistence.execute_async.await_count == 2
-
-
 class TestSpaceServiceCreditsCache:
     """Tests for credits cache behavior."""
 

tests/unit_tests/box/test_box_connector.py

@@ -306,10 +306,19 @@ def test_box_runtime_connector_rejects_relay_context_from_other_instance(
         )
 
 
-def test_external_box_runtime_fails_closed_without_control_token(monkeypatch: pytest.MonkeyPatch):
+def test_external_box_runtime_control_headers_are_tokenless_when_secret_is_unset(
+    monkeypatch: pytest.MonkeyPatch,
+):
     monkeypatch.delenv(BOX_CONTROL_TOKEN_ENV, raising=False)
     connector = BoxRuntimeConnector(make_app(Mock(), runtime_endpoint='http://box-runtime:5410'))
 
+    assert connector.get_control_headers() == {BOX_INSTANCE_HEADER: 'instance-a'}
+
+
+def test_external_box_runtime_rejects_invalid_configured_control_token(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setenv(BOX_CONTROL_TOKEN_ENV, 'too-short')
+    connector = BoxRuntimeConnector(make_app(Mock(), runtime_endpoint='http://box-runtime:5410'))
+
     with pytest.raises(BoxRuntimeUnavailableError, match=BOX_CONTROL_TOKEN_ENV):
         connector.get_control_headers()
 

tests/unit_tests/platform/test_itchat_adapter.py

@@ -0,0 +1,130 @@
+"""Tests for itchat adapter group/private message conversion."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+
+from langbot.pkg.platform import botmgr as _botmgr  # noqa: F401
+
+from langbot.pkg.platform.sources.itchat import ItchatAdapter, ItchatEventConverter
+
+
+def _make_adapter(bot_account_id: str = '@bot_wxid', bot_nickname: str = 'MyBot'):
+    adapter = SimpleNamespace(
+        bot_account_id=bot_account_id,
+        _bot_nickname=bot_nickname,
+        _core=SimpleNamespace(storageClass=SimpleNamespace(userName=bot_account_id)),
+        _get_obj_value=ItchatAdapter._get_obj_value,
+    )
+    return adapter
+
+
+def _make_converter(adapter) -> ItchatEventConverter:
+    return ItchatEventConverter(adapter_ref=lambda: adapter)
+
+
+def test_group_text_becomes_group_message():
+    converter = _make_converter(_make_adapter())
+
+    msg = {
+        'FromUserName': '@@group_wxid',
+        'Type': 'Text',
+        'Text': 'hello',
+        'ActualUserName': '@member_wxid',
+        'ActualNickName': 'MemberNick',
+        'IsAt': False,
+        'CreateTime': 123456,
+        'User': SimpleNamespace(NickName='Group Name'),
+    }
+
+    event = converter.target2yiri(msg)
+
+    assert isinstance(event, platform_events.GroupMessage)
+    assert isinstance(event.sender, platform_entities.GroupMember)
+    assert event.sender.id == '@member_wxid'
+    assert event.sender.member_name == 'MemberNick'
+    assert event.sender.group.id == '@@group_wxid'
+    assert event.sender.group.name == 'Group Name'
+
+    components = list(event.message_chain)
+    assert len(components) == 1
+    assert isinstance(components[0], platform_message.Plain)
+    assert components[0].text == 'hello'
+
+
+def test_private_text_becomes_friend_message():
+    converter = _make_converter(_make_adapter())
+
+    msg = {
+        'FromUserName': '@friend_wxid',
+        'Type': 'Text',
+        'Text': 'hi',
+        'CreateTime': 123456,
+        'User': SimpleNamespace(NickName='FriendNick', RemarkName='FriendRemark'),
+    }
+
+    event = converter.target2yiri(msg)
+
+    assert isinstance(event, platform_events.FriendMessage)
+    assert isinstance(event.sender, platform_entities.Friend)
+    assert event.sender.id == '@friend_wxid'
+    assert event.sender.nickname == 'FriendNick'
+    assert event.sender.remark == 'FriendRemark'
+
+
+def test_bot_own_message_is_ignored():
+    converter = _make_converter(_make_adapter(bot_account_id='@bot_wxid'))
+
+    msg = {
+        'FromUserName': '@bot_wxid',
+        'Type': 'Text',
+        'Text': 'self echo',
+    }
+
+    assert converter.target2yiri(msg) is None
+
+
+def test_group_at_bot_strips_prefix_and_adds_at():
+    converter = _make_converter(_make_adapter(bot_account_id='@bot_wxid', bot_nickname='MyBot'))
+
+    msg = {
+        'FromUserName': '@@group_wxid',
+        'Type': 'Text',
+        'Text': '@MyBot hello world',
+        'ActualUserName': '@member_wxid',
+        'ActualNickName': 'MemberNick',
+        'IsAt': True,
+        'CreateTime': 123456,
+        'User': SimpleNamespace(NickName='Group Name'),
+    }
+
+    event = converter.target2yiri(msg)
+
+    assert isinstance(event, platform_events.GroupMessage)
+    components = list(event.message_chain)
+    assert len(components) == 2
+    assert isinstance(components[0], platform_message.At)
+    assert components[0].target == '@bot_wxid'
+    assert isinstance(components[1], platform_message.Plain)
+    assert components[1].text == 'hello world'
+
+
+def test_group_message_without_sender_is_ignored():
+    converter = _make_converter(_make_adapter())
+
+    msg = {
+        'FromUserName': '@@group_wxid',
+        'Type': 'Text',
+        'Text': 'system note',
+        'ActualUserName': '',
+        'ActualNickName': '',
+        'IsAt': False,
+        'CreateTime': 123456,
+        'User': SimpleNamespace(NickName='Group Name'),
+    }
+
+    assert converter.target2yiri(msg) is None

tests/unit_tests/plugin/test_handler_tenancy.py

@@ -444,3 +444,23 @@ async def test_host_to_runtime_action_carries_trusted_connector_context():
         'runtime_id': 'runtime-a',
     }
     assert request.get('context') is None
+
+
+@pytest.mark.asyncio
+async def test_get_debug_info_converts_execution_context_to_sdk_action_context():
+    runtime_handler, _app, _installation_context = make_handler()
+    runtime_handler.call_action = AsyncMock(return_value={'plugin_debug_key': 'debug-key'})
+    execution_context = ExecutionContext(
+        instance_uuid='instance-a',
+        workspace_uuid='workspace-a',
+        placement_generation=7,
+    )
+
+    result = await runtime_handler.get_debug_info(execution_context)
+
+    assert result == {'plugin_debug_key': 'debug-key'}
+    assert runtime_handler.call_action.await_args.kwargs['action_context'] == ActionContext(
+        instance_uuid='instance-a',
+        workspace_uuid='workspace-a',
+        placement_generation=7,
+    )

uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.11, <4.0"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -1018,7 +1018,7 @@ name = "cuda-bindings"
 version = "13.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cuda-pathfinder" },
+    { name = "cuda-pathfinder", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/51/6b/457ca12dad3ee9bfcc9a545cfd6b64b359ba49de40f776f6e028e678f262/cuda_bindings-13.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5879712accf6e14bb01aa5e67440eb84998b8d104b509cc7a6dc0b8f656a474", size = 6053539, upload-time = "2026-05-29T23:11:43.19Z" },
@@ -1051,34 +1051,34 @@ wheels = [
 
 [package.optional-dependencies]
 cudart = [
-    { name = "nvidia-cuda-runtime" },
+    { name = "nvidia-cuda-runtime", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 cufft = [
-    { name = "nvidia-cufft" },
+    { name = "nvidia-cufft", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 cufile = [
-    { name = "nvidia-cufile" },
+    { name = "nvidia-cufile", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 cupti = [
-    { name = "nvidia-cuda-cupti" },
+    { name = "nvidia-cuda-cupti", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 curand = [
-    { name = "nvidia-curand" },
+    { name = "nvidia-curand", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 cusolver = [
-    { name = "nvidia-cusolver" },
+    { name = "nvidia-cusolver", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 cusparse = [
-    { name = "nvidia-cusparse" },
+    { name = "nvidia-cusparse", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 nvjitlink = [
-    { name = "nvidia-nvjitlink" },
+    { name = "nvidia-nvjitlink", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 nvrtc = [
-    { name = "nvidia-cuda-nvrtc" },
+    { name = "nvidia-cuda-nvrtc", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 nvtx = [
-    { name = "nvidia-nvtx" },
+    { name = "nvidia-nvtx", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
 ]
 
 [[package]]
@@ -1814,6 +1814,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
 ]
 
+[[package]]
+name = "itchat-uos"
+version = "1.5.0.dev0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pypng" },
+    { name = "pyqrcode" },
+    { name = "requests" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/2b/0be7e46195dc3c461518b046a6fb9c34c97cd2fd44847b840a0011686575/itchat_uos-1.5.0.dev0-py3-none-any.whl", hash = "sha256:0293b77cab31fa8c9c2144ea8b5636d43836f47855beba0c603ad3fb1ff89625", size = 52507, upload-time = "2022-07-14T02:38:32.507Z" },
+]
+
 [[package]]
 name = "itsdangerous"
 version = "2.2.0"
@@ -2035,6 +2048,7 @@ dependencies = [
     { name = "ebooklib" },
     { name = "gewechat-client" },
     { name = "html2text" },
+    { name = "itchat-uos" },
     { name = "langbot-plugin" },
     { name = "langchain" },
     { name = "langchain-core" },
@@ -2125,7 +2139,8 @@ requires-dist = [
     { name = "ebooklib", specifier = ">=0.18" },
     { name = "gewechat-client", specifier = ">=0.1.5" },
     { name = "html2text", specifier = ">=2024.2.26" },
-    { name = "langbot-plugin", git = "https://github.com/langbot-app/langbot-plugin-sdk.git?rev=9d216208cdfb41f0cb7fcb64632e2a46816d6dc6" },
+    { name = "itchat-uos", specifier = ">=1.5.0.dev0" },
+    { name = "langbot-plugin", git = "https://github.com/langbot-app/langbot-plugin-sdk.git?rev=7b559da430a50f80a7d30c9d3d66f088503ddbb3" },
     { name = "langchain", specifier = ">=1.3.9" },
     { name = "langchain-core", specifier = ">=1.3.3" },
     { name = "langchain-text-splitters", specifier = ">=1.1.2" },
@@ -2191,8 +2206,8 @@ dev = [
 
 [[package]]
 name = "langbot-plugin"
-version = "0.5.0"
-source = { git = "https://github.com/langbot-app/langbot-plugin-sdk.git?rev=9d216208cdfb41f0cb7fcb64632e2a46816d6dc6#9d216208cdfb41f0cb7fcb64632e2a46816d6dc6" }
+version = "0.5.1"
+source = { git = "https://github.com/langbot-app/langbot-plugin-sdk.git?rev=7b559da430a50f80a7d30c9d3d66f088503ddbb3#7b559da430a50f80a7d30c9d3d66f088503ddbb3" }
 dependencies = [
     { name = "aiofiles" },
     { name = "aiohttp" },
@@ -3238,7 +3253,7 @@ name = "nvidia-cublas"
 version = "13.1.1.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cuda-nvrtc" },
+    { name = "nvidia-cuda-nvrtc", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" },
@@ -3277,7 +3292,7 @@ name = "nvidia-cudnn-cu13"
 version = "9.20.0.48"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas" },
+    { name = "nvidia-cublas", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" },
@@ -3289,7 +3304,7 @@ name = "nvidia-cufft"
 version = "12.0.0.61"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink" },
+    { name = "nvidia-nvjitlink", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
@@ -3319,9 +3334,9 @@ name = "nvidia-cusolver"
 version = "12.0.4.66"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas" },
-    { name = "nvidia-cusparse" },
-    { name = "nvidia-nvjitlink" },
+    { name = "nvidia-cublas", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-cusparse", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "nvidia-nvjitlink", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
@@ -3333,7 +3348,7 @@ name = "nvidia-cusparse"
 version = "12.6.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink" },
+    { name = "nvidia-nvjitlink", marker = "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
@@ -4517,6 +4532,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" },
 ]
 
+[[package]]
+name = "pyqrcode"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/61/f07226075c347897937d4086ef8e55f0a62ae535e28069884ac68d979316/PyQRCode-1.2.1.tar.gz", hash = "sha256:fdbf7634733e56b72e27f9bce46e4550b75a3a2c420414035cae9d9d26b234d5", size = 36989, upload-time = "2016-06-20T03:28:03.411Z" }
+
 [[package]]
 name = "pyreadline3"
 version = "3.5.4"
@@ -5163,10 +5184,10 @@ name = "scikit-learn"
 version = "1.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "joblib" },
-    { name = "numpy" },
-    { name = "scipy" },
-    { name = "threadpoolctl" },
+    { name = "joblib", marker = "python_full_version >= '3.14'" },
+    { name = "numpy", marker = "python_full_version >= '3.14'" },
+    { name = "scipy", marker = "python_full_version >= '3.14'" },
+    { name = "threadpoolctl", marker = "python_full_version >= '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" }
 wheels = [
@@ -5213,7 +5234,7 @@ name = "scipy"
 version = "1.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", marker = "python_full_version >= '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -5284,14 +5305,14 @@ name = "sentence-transformers"
 version = "5.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "huggingface-hub" },
-    { name = "numpy" },
-    { name = "scikit-learn" },
-    { name = "scipy" },
-    { name = "torch" },
-    { name = "tqdm" },
-    { name = "transformers" },
-    { name = "typing-extensions" },
+    { name = "huggingface-hub", marker = "python_full_version >= '3.14'" },
+    { name = "numpy", marker = "python_full_version >= '3.14'" },
+    { name = "scikit-learn", marker = "python_full_version >= '3.14'" },
+    { name = "scipy", marker = "python_full_version >= '3.14'" },
+    { name = "torch", marker = "python_full_version >= '3.14'" },
+    { name = "tqdm", marker = "python_full_version >= '3.14'" },
+    { name = "transformers", marker = "python_full_version >= '3.14'" },
+    { name = "typing-extensions", marker = "python_full_version >= '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5b/30/21664028fc0776eb1ca024879480bbbab36f02923a8ff9e4cae5a150fa35/sentence_transformers-5.2.3.tar.gz", hash = "sha256:3cd3044e1f3fe859b6a1b66336aac502eaae5d3dd7d5c8fc237f37fbf58137c7", size = 381623, upload-time = "2026-02-17T14:05:20.238Z" }
 wheels = [
@@ -5664,21 +5685,21 @@ name = "torch"
 version = "2.12.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
-    { name = "cuda-toolkit", extra = ["cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" },
-    { name = "filelock" },
-    { name = "fsspec" },
-    { name = "jinja2" },
-    { name = "networkx" },
-    { name = "nvidia-cublas", marker = "sys_platform == 'linux'" },
-    { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" },
-    { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" },
-    { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" },
-    { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" },
-    { name = "setuptools" },
-    { name = "sympy" },
-    { name = "triton", marker = "sys_platform == 'linux'" },
-    { name = "typing-extensions" },
+    { name = "cuda-bindings", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "cuda-toolkit", extra = ["cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "filelock", marker = "python_full_version >= '3.14'" },
+    { name = "fsspec", marker = "python_full_version >= '3.14'" },
+    { name = "jinja2", marker = "python_full_version >= '3.14'" },
+    { name = "networkx", marker = "python_full_version >= '3.14'" },
+    { name = "nvidia-cublas", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu13", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu13", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu13", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu13", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "setuptools", marker = "python_full_version >= '3.14'" },
+    { name = "sympy", marker = "python_full_version >= '3.14'" },
+    { name = "triton", marker = "python_full_version >= '3.14' and sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "python_full_version >= '3.14'" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/59/38/7028d3be540f1dcdf41660a2b01d0c51d2cb73915fe370d84e4d277a6d47/torch-2.12.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ef81f503912effea2ce3d9b12a2e3a6ed488943e91271c90c7a829f60baf6aa2", size = 87975425, upload-time = "2026-06-17T21:08:34.094Z" },
@@ -5720,15 +5741,15 @@ name = "transformers"
 version = "5.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "huggingface-hub" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "pyyaml" },
-    { name = "regex" },
-    { name = "safetensors" },
-    { name = "tokenizers" },
-    { name = "tqdm" },
-    { name = "typer" },
+    { name = "huggingface-hub", marker = "python_full_version >= '3.14'" },
+    { name = "numpy", marker = "python_full_version >= '3.14'" },
+    { name = "packaging", marker = "python_full_version >= '3.14'" },
+    { name = "pyyaml", marker = "python_full_version >= '3.14'" },
+    { name = "regex", marker = "python_full_version >= '3.14'" },
+    { name = "safetensors", marker = "python_full_version >= '3.14'" },
+    { name = "tokenizers", marker = "python_full_version >= '3.14'" },
+    { name = "tqdm", marker = "python_full_version >= '3.14'" },
+    { name = "typer", marker = "python_full_version >= '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", hash = "sha256:009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557", size = 8830831, upload-time = "2026-03-04T17:41:46.119Z" }
 wheels = [
@@ -5989,9 +6010,9 @@ name = "valkey-glide"
 version = "2.4.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "anyio" },
-    { name = "protobuf" },
-    { name = "sniffio" },
+    { name = "anyio", marker = "sys_platform != 'win32'" },
+    { name = "protobuf", marker = "sys_platform != 'win32'" },
+    { name = "sniffio", marker = "sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/72/a2/582b34c6acc8dc857c537f6007459cba48dfa0dc404789a657e5c1a998c0/valkey_glide-2.4.1.tar.gz", hash = "sha256:f1155d84156d11b90488aa67e90102f0bf98a45314f5b99308ac9074c05f7241", size = 898030, upload-time = "2026-05-28T21:41:55.881Z" }
 wheels = [

web/.env.example

@@ -1,5 +1 @@
-# Leave empty in development to use Vite's same-origin proxy. This keeps API,
-# login, and WebSocket requests working when the UI is opened from another
-# device on the local network.
-VITE_API_BASE_URL=
-VITE_API_PROXY_TARGET=http://127.0.0.1:5300
+VITE_API_BASE_URL=http://localhost:5300

web/src/app/home/bots/BotDetailContent.tsx

@@ -2,6 +2,7 @@ import { useState, useEffect, useRef, useCallback } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
 import { Button } from '@/components/ui/button';
+import { Badge } from '@/components/ui/badge';
 import { Switch } from '@/components/ui/switch';
 import { Label } from '@/components/ui/label';
 import {
@@ -26,9 +27,79 @@ import type { BotSessionMonitorHandle } from '@/app/home/bots/components/bot-ses
 import { httpClient } from '@/app/infra/http/HttpClient';
 import { useSidebarData } from '@/app/home/components/home-sidebar/SidebarDataContext';
 import { useTranslation } from 'react-i18next';
-import { Settings, FileText, Users, RefreshCw, Trash2 } from 'lucide-react';
+import {
+  Settings,
+  FileText,
+  Users,
+  RefreshCw,
+  Trash2,
+  CircleCheck,
+  CircleAlert,
+  Loader2,
+  CircleOff,
+} from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { toast } from 'sonner';
+import type { Bot, BotAdapterRuntimeStatus } from '@/app/infra/entities/api';
+
+function getBotRuntimeStatus(bot: Bot | null): BotAdapterRuntimeStatus | null {
+  return bot?.adapter_runtime_values?.runtime_status ?? null;
+}
+
+function RuntimeStatusBadge({
+  status,
+}: {
+  status: BotAdapterRuntimeStatus | null;
+}) {
+  const { t } = useTranslation();
+  if (!status) return null;
+
+  const value = status?.connection_status ?? 'disconnected';
+
+  const config = {
+    connected: {
+      label: t('bots.runtimeConnected'),
+      className: 'border-emerald-500/30 bg-emerald-500/10 text-emerald-700',
+      icon: CircleCheck,
+    },
+    connecting: {
+      label: t('bots.runtimeConnecting'),
+      className: 'border-amber-500/30 bg-amber-500/10 text-amber-700',
+      icon: Loader2,
+    },
+    disconnected: {
+      label: t('bots.runtimeDisconnected'),
+      className: 'border-muted-foreground/20 bg-muted text-muted-foreground',
+      icon: CircleOff,
+    },
+    error: {
+      label: t('bots.runtimeError'),
+      className: 'border-destructive/30 bg-destructive/10 text-destructive',
+      icon: CircleAlert,
+    },
+  }[value];
+
+  const Icon = config.icon;
+
+  return (
+    <div className="flex min-w-0 items-center gap-2">
+      <Badge
+        variant="outline"
+        className={cn('h-6 gap-1.5 px-2 text-xs', config.className)}
+      >
+        <Icon
+          className={cn('size-3.5', value === 'connecting' && 'animate-spin')}
+        />
+        {config.label}
+      </Badge>
+      {status?.connection_error && (
+        <span className="max-w-[360px] truncate text-xs text-destructive">
+          {status.connection_error}
+        </span>
+      )}
+    </div>
+  );
+}
 import { useCurrentWorkspace } from '@/app/infra/http';
 
 export default function BotDetailContent({ id }: { id: string }) {
@@ -64,16 +135,24 @@ export default function BotDetailContent({ id }: { id: string }) {
   // Enable state managed here so the header switch works
   const [botEnabled, setBotEnabled] = useState(true);
   const [enableLoaded, setEnableLoaded] = useState(false);
+  const [botDetail, setBotDetail] = useState<Bot | null>(null);
+
+  const fetchBotDetail = useCallback(async () => {
+    if (isCreateMode) return;
+    const res = await httpClient.getBot(id);
+    setBotDetail(res.bot);
+    setBotEnabled(res.bot.enable ?? true);
+    setEnableLoaded(true);
+  }, [id, isCreateMode]);
 
   // Fetch bot enable state
   useEffect(() => {
     if (!isCreateMode) {
-      httpClient.getBot(id).then((res) => {
-        setBotEnabled(res.bot.enable ?? true);
-        setEnableLoaded(true);
-      });
+      fetchBotDetail();
+      const timer = window.setInterval(fetchBotDetail, 5000);
+      return () => window.clearInterval(timer);
     }
-  }, [id, isCreateMode]);
+  }, [fetchBotDetail, isCreateMode]);
 
   const handleEnableToggle = useCallback(
     async (checked: boolean) => {
@@ -101,9 +180,7 @@ export default function BotDetailContent({ id }: { id: string }) {
 
   function handleFormSubmit() {
     // Re-sync enable state after form save (form may update enable too)
-    httpClient.getBot(id).then((res) => {
-      setBotEnabled(res.bot.enable ?? true);
-    });
+    fetchBotDetail();
     refreshBots();
   }
 
@@ -184,6 +261,7 @@ export default function BotDetailContent({ id }: { id: string }) {
                 </Label>
               </div>
             )}
+            <RuntimeStatusBadge status={getBotRuntimeStatus(botDetail)} />
           </div>
           {canManage && (
             <Button

web/src/app/home/bots/components/bot-log/view/BotLogListComponent.tsx

@@ -20,7 +20,6 @@ export function BotLogListComponent({
   autoExpandImages = false,
   hideDetailedLogsLink = false,
   hideToolbar = false,
-  onMessageReceived,
 }: {
   botId: string;
   /** When true, log entries with images are rendered expanded by default */
@@ -29,8 +28,6 @@ export function BotLogListComponent({
   hideDetailedLogsLink?: boolean;
   /** When true, hides the entire toolbar (auto-refresh, level filter, detailed logs link) */
   hideToolbar?: boolean;
-  /** Called after an inbound person/group message appears in the bot log. */
-  onMessageReceived?: () => void;
 }) {
   const { t } = useTranslation();
   const navigate = useNavigate();
@@ -44,8 +41,6 @@ export function BotLogListComponent({
   ]);
   const listContainerRef = useRef<HTMLDivElement>(null);
   const botLogListRef = useRef<BotLog[]>(botLogList);
-  const onMessageReceivedRef = useRef(onMessageReceived);
-  onMessageReceivedRef.current = onMessageReceived;
 
   const logLevels = [
     { value: 'error', label: 'ERROR' },
@@ -113,9 +108,6 @@ export function BotLogListComponent({
     manager.subscribeLogPush(handleBotLogPush);
     manager.loadFirstPage().then((response) => {
       setBotLogList(response.reverse());
-      if (response.some((log) => Boolean(log.message_session_id))) {
-        onMessageReceivedRef.current?.();
-      }
     });
     listenScroll();
   }
@@ -146,9 +138,6 @@ export function BotLogListComponent({
 
   function handleBotLogPush(response: BotLog[]) {
     setBotLogList(response.reverse());
-    if (response.some((log) => Boolean(log.message_session_id))) {
-      onMessageReceivedRef.current?.();
-    }
   }
 
   const handleScroll = useCallback(

web/src/app/home/components/dynamic-form/DynamicFormComponent.tsx

@@ -688,7 +688,10 @@ export default function DynamicFormComponent({
           onSuccess={(credentials) => {
             for (const [key, value] of Object.entries(credentials)) {
               if (value) {
-                form.setValue(key as keyof FormValues, value as never);
+                form.setValue(key as keyof FormValues, value as never, {
+                  shouldDirty: true,
+                  shouldValidate: true,
+                });
               }
             }
           }}

web/src/app/home/components/qrcode-login/QrCodeLoginDialog.tsx

@@ -15,12 +15,14 @@ import {
   XCircle,
 } from 'lucide-react';
 import QRCode from 'qrcode';
+import { getActiveWorkspaceUuid } from '@/app/infra/http/workspaceContext';
 
 export type QrLoginPlatform =
   | 'feishu'
   | 'weixin'
   | 'dingtalk'
   | 'wecombot'
+  | 'itchat'
   | 'qqofficial';
 
 interface PlatformConfig {
@@ -55,12 +57,12 @@ const PLATFORM_CONFIGS: Record<QrLoginPlatform, PlatformConfig> = {
   },
   weixin: {
     titleKey: 'weixin.scanLogin',
-    connectingKey: 'feishu.connecting',
+    connectingKey: 'weixin.connecting',
     scanQRCodeKey: 'weixin.scanQRCode',
-    waitingKey: 'feishu.waitingForScan',
+    waitingKey: 'weixin.waitingForScan',
     successKey: 'weixin.loginSuccess',
     failedKey: 'weixin.loginFailed',
-    retryKey: 'feishu.retry',
+    retryKey: 'weixin.retry',
     apiBase: '/api/v1/platform/adapters/weixin/login',
     extractSuccess: (data) => ({
       token: data.token,
@@ -98,6 +100,20 @@ const PLATFORM_CONFIGS: Record<QrLoginPlatform, PlatformConfig> = {
     }),
     successNoteKey: 'wecombot.robotNameNote',
   },
+  itchat: {
+    titleKey: 'itchat.scanLogin',
+    connectingKey: 'itchat.connecting',
+    scanQRCodeKey: 'itchat.scanQRCode',
+    waitingKey: 'itchat.waitingForScan',
+    successKey: 'itchat.loginSuccess',
+    failedKey: 'itchat.loginFailed',
+    retryKey: 'itchat.retry',
+    apiBase: '/api/v1/platform/adapters/itchat/login',
+    extractSuccess: (data) => ({
+      account_id: data.wxid || '',
+      nickname: data.nickname || '',
+    }),
+  },
   qqofficial: {
     titleKey: 'qqofficial.createBinding',
     connectingKey: 'qqofficial.connecting',
@@ -138,6 +154,7 @@ export default function QrCodeLoginDialog({
 
   const [state, setState] = useState<DialogState>('connecting');
   const [qrDataUrl, setQrDataUrl] = useState('');
+  const qrDataUrlRef = useRef('');
   const [expireIn, setExpireIn] = useState(0);
   const [errorMessage, setErrorMessage] = useState('');
   const [successMeta, setSuccessMeta] = useState('');
@@ -146,6 +163,8 @@ export default function QrCodeLoginDialog({
   const checkExpiredRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const abortRef = useRef<AbortController | null>(null);
   const sessionIdRef = useRef<string | null>(null);
+  const sessionWorkspaceUuidRef = useRef<string | null>(null);
+  const sessionApiBaseRef = useRef('');
   const baseUrlRef = useRef('');
   const cleanedRef = useRef(false);
 
@@ -180,18 +199,23 @@ export default function QrCodeLoginDialog({
     }
     if (sessionIdRef.current) {
       const token = localStorage.getItem('token');
-      const baseUrl =
-        import.meta.env.VITE_API_BASE_URL || window.location.origin;
+      const workspaceUuid = sessionWorkspaceUuidRef.current;
       fetch(
-        `${baseUrl}${platformConfigRef.current.apiBase}/${sessionIdRef.current}`,
+        `${baseUrlRef.current}${sessionApiBaseRef.current}/${sessionIdRef.current}`,
         {
           method: 'DELETE',
-          headers: { Authorization: `Bearer ${token}` },
+          headers: {
+            Authorization: `Bearer ${token}`,
+            ...(workspaceUuid ? { 'X-Workspace-Id': workspaceUuid } : {}),
+          },
           keepalive: true,
         },
       ).catch(() => {});
       sessionIdRef.current = null;
     }
+    sessionWorkspaceUuidRef.current = null;
+    sessionApiBaseRef.current = '';
+    baseUrlRef.current = '';
   }, []);
 
   const startLogin = useCallback(async () => {
@@ -199,11 +223,13 @@ export default function QrCodeLoginDialog({
     cleanedRef.current = false;
     setState('connecting');
     setQrDataUrl('');
+    qrDataUrlRef.current = '';
     setExpireIn(0);
     setErrorMessage('');
     setSuccessMeta('');
 
     const token = localStorage.getItem('token');
+    const workspaceUuid = getActiveWorkspaceUuid();
     const baseUrl = import.meta.env.VITE_API_BASE_URL || window.location.origin;
     baseUrlRef.current = baseUrl;
     const cfg = platformConfigRef.current;
@@ -214,7 +240,10 @@ export default function QrCodeLoginDialog({
 
       const res = await fetch(`${baseUrl}${cfg.apiBase}`, {
         method: 'POST',
-        headers: { Authorization: `Bearer ${token}` },
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...(workspaceUuid ? { 'X-Workspace-Id': workspaceUuid } : {}),
+        },
         signal: controller.signal,
       });
 
@@ -225,15 +254,19 @@ export default function QrCodeLoginDialog({
 
       const { session_id, qr_data_url, qr_url, expire_at } = json.data;
       sessionIdRef.current = session_id;
+      sessionWorkspaceUuidRef.current = workspaceUuid;
+      sessionApiBaseRef.current = cfg.apiBase;
 
       if (qr_data_url) {
         setQrDataUrl(qr_data_url);
+        qrDataUrlRef.current = qr_data_url;
       } else if (qr_url) {
         const dataUrl = await QRCode.toDataURL(qr_url, {
           width: 224,
           margin: 2,
         });
         setQrDataUrl(dataUrl);
+        qrDataUrlRef.current = dataUrl;
       }
       setState('waiting');
 
@@ -270,11 +303,19 @@ export default function QrCodeLoginDialog({
                 `${baseUrlRef.current}${cfg.apiBase}/${sessionIdRef.current}`,
                 {
                   method: 'DELETE',
-                  headers: { Authorization: `Bearer ${token}` },
+                  headers: {
+                    Authorization: `Bearer ${token}`,
+                    ...(workspaceUuid
+                      ? { 'X-Workspace-Id': workspaceUuid }
+                      : {}),
+                  },
                   keepalive: true,
                 },
               ).catch(() => {});
               sessionIdRef.current = null;
+              sessionWorkspaceUuidRef.current = null;
+              sessionApiBaseRef.current = '';
+              baseUrlRef.current = '';
             }
             setState('expired');
           }
@@ -286,7 +327,12 @@ export default function QrCodeLoginDialog({
         try {
           const pollRes = await fetch(
             `${baseUrl}${cfg.apiBase}/status/${session_id}`,
-            { headers: { Authorization: `Bearer ${token}` } },
+            {
+              headers: {
+                Authorization: `Bearer ${token}`,
+                ...(workspaceUuid ? { 'X-Workspace-Id': workspaceUuid } : {}),
+              },
+            },
           );
           if (!pollRes.ok) return;
 
@@ -320,6 +366,19 @@ export default function QrCodeLoginDialog({
             cleanup();
             setExpireIn(0);
             setState('expired');
+          } else if (status === 'waiting') {
+            // Update QR data URL if regenerated (e.g. itchat QR expiry)
+            if (rest.qr_data_url && rest.qr_data_url !== qrDataUrlRef.current) {
+              setQrDataUrl(rest.qr_data_url);
+              qrDataUrlRef.current = rest.qr_data_url;
+            }
+            if (rest.expire_at) {
+              const remaining = Math.max(
+                0,
+                Math.floor(rest.expire_at - Date.now() / 1000),
+              );
+              setExpireIn(remaining);
+            }
           }
         } catch {
           // ignore poll errors

web/src/app/infra/entities/api/index.ts

@@ -203,6 +203,28 @@ export interface ApiRespPlatformBot {
   bot: Bot;
 }
 
+export type BotAdapterConnectionStatus =
+  | 'connecting'
+  | 'connected'
+  | 'disconnected'
+  | 'error';
+
+export interface BotAdapterRuntimeStatus {
+  connection_status?: BotAdapterConnectionStatus;
+  connection_error?: string;
+  last_connected_at?: number | null;
+  last_disconnected_at?: number | null;
+}
+
+export interface BotAdapterRuntimeValues {
+  bot_account_id?: string;
+  webhook_url?: string | null;
+  webhook_full_url?: string | null;
+  extra_webhook_full_url?: string | null;
+  runtime_status?: BotAdapterRuntimeStatus;
+  [key: string]: unknown;
+}
+
 export interface Bot {
   uuid?: string;
   name: string;
@@ -215,7 +237,7 @@ export interface Bot {
   pipeline_routing_rules?: PipelineRoutingRule[];
   created_at?: string;
   updated_at?: string;
-  adapter_runtime_values?: object;
+  adapter_runtime_values?: BotAdapterRuntimeValues;
 }
 
 export type RoutingRuleOperator =
@@ -363,9 +385,7 @@ export interface WizardProgress {
   step: number;
   selected_adapter: string | null;
   created_bot_uuid: string | null;
-  created_pipeline_uuid?: string | null;
   bot_saved: boolean;
-  message_received?: boolean;
   selected_runner: string | null;
 }
 

web/src/app/infra/http/BackendClient.ts

@@ -461,15 +461,6 @@ export class BackendClient extends BaseHttpClient {
     return this.post(`/api/v1/platform/bots/${botId}/logs`, request);
   }
 
-  public testHttpBotInbound(
-    botId: string,
-    message: string,
-  ): Promise<{ session_id: string; accepted_message_id: string }> {
-    return this.post(`/api/v1/platform/bots/${botId}/test-inbound`, {
-      message,
-    });
-  }
-
   public getBotSessions(
     botId: string,
     limit: number = 100,
@@ -1055,21 +1046,12 @@ export class BackendClient extends BaseHttpClient {
     step: number;
     selected_adapter: string | null;
     created_bot_uuid: string | null;
-    created_pipeline_uuid?: string | null;
     bot_saved: boolean;
-    message_received?: boolean;
     selected_runner: string | null;
   }): Promise<void> {
     return this.put('/api/v1/system/wizard/progress', progress);
   }
 
-  public getWizardRecommendedModel(): Promise<{
-    uuid: string;
-    name: string;
-  }> {
-    return this.get('/api/v1/system/wizard/recommended-model');
-  }
-
   public getAsyncTasks(params?: {
     type?: string;
     kind?: string;

web/src/app/wizard/page.tsx

@@ -8,16 +8,10 @@ import {
   ArrowRight,
   Check,
   Sparkles,
+  PartyPopper,
   Loader2,
   X,
   ExternalLink,
-  Cable,
-  Settings2,
-  Blocks,
-  Copy,
-  Send,
-  Webhook,
-  MessageSquare,
 } from 'lucide-react';
 
 import { httpClient } from '@/app/infra/http/HttpClient';
@@ -27,7 +21,12 @@ import {
   bootstrapWorkspaceSession,
   initializeSystemInfo,
 } from '@/app/infra/http';
-import { Adapter, Bot, WizardProgress } from '@/app/infra/entities/api';
+import {
+  Adapter,
+  Bot,
+  Pipeline,
+  WizardProgress,
+} from '@/app/infra/entities/api';
 import { IDynamicFormItemSchema } from '@/app/infra/entities/form/dynamic';
 import {
   PipelineConfigTab,
@@ -48,13 +47,7 @@ import {
 import { getAdapterDocUrl } from '@/app/infra/entities/adapter-docs';
 import i18n from 'i18next';
 
-import {
-  ensureHttpBotSigningSecret,
-  getErrorMessage,
-} from '@/app/wizard/utils';
-
 import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
 import {
   Card,
   CardContent,
@@ -78,7 +71,7 @@ import {
 // Types
 // ---------------------------------------------------------------------------
 
-const TOTAL_STEPS = 3;
+const TOTAL_STEPS = 4;
 
 // ---------------------------------------------------------------------------
 // Main Wizard Page (full-screen, no sidebar)
@@ -100,9 +93,6 @@ export default function WizardPage() {
   );
   const [runnerConfig, setRunnerConfig] = useState<Record<string, unknown>>({});
   const [createdBotUuid, setCreatedBotUuid] = useState<string | null>(null);
-  const [createdPipelineUuid, setCreatedPipelineUuid] = useState<string | null>(
-    null,
-  );
   const [webhookUrl, setWebhookUrl] = useState<string>('');
   const [extraWebhookUrl, setExtraWebhookUrl] = useState<string>('');
 
@@ -116,10 +106,6 @@ export default function WizardPage() {
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [isSavingBot, setIsSavingBot] = useState(false);
   const [botSaved, setBotSaved] = useState(false);
-  const [messageReceived, setMessageReceived] = useState(false);
-  const [aiChoice, setAiChoice] = useState<
-    'external' | 'own-model' | 'more-features' | null
-  >(null);
 
   // ---- Helper: persist wizard progress to backend (fire-and-forget) ----
   const saveProgress = useCallback(
@@ -128,25 +114,14 @@ export default function WizardPage() {
         step: overrides.step ?? currentStep,
         selected_adapter: overrides.selected_adapter ?? selectedAdapter,
         created_bot_uuid: overrides.created_bot_uuid ?? createdBotUuid,
-        created_pipeline_uuid:
-          overrides.created_pipeline_uuid ?? createdPipelineUuid,
         bot_saved: overrides.bot_saved ?? botSaved,
-        message_received: overrides.message_received ?? messageReceived,
         selected_runner: overrides.selected_runner ?? selectedRunner,
       };
       httpClient.saveWizardProgress(progress).catch((err) => {
         console.error('Failed to save wizard progress', err);
       });
     },
-    [
-      currentStep,
-      selectedAdapter,
-      createdBotUuid,
-      createdPipelineUuid,
-      botSaved,
-      messageReceived,
-      selectedRunner,
-    ],
+    [currentStep, selectedAdapter, createdBotUuid, botSaved, selectedRunner],
   );
 
   // ---- Fetch remote data & restore progress ----
@@ -182,30 +157,13 @@ export default function WizardPage() {
             const botData = await httpClient.getBot(progress.created_bot_uuid);
             if (cancelled) return;
 
-            const restoredAdapter =
-              progress.selected_adapter ?? botData.bot.adapter;
-            const restoredConfig = (botData.bot.adapter_config ?? {}) as Record<
-              string,
-              unknown
-            >;
-            const configToRestore = ensureHttpBotSigningSecret(
-              restoredAdapter,
-              restoredConfig,
-            );
-            const configNeedsSave = configToRestore !== restoredConfig;
-
-            setSelectedAdapter(restoredAdapter);
+            setSelectedAdapter(progress.selected_adapter);
             setCreatedBotUuid(progress.created_bot_uuid);
-            setCreatedPipelineUuid(progress.created_pipeline_uuid ?? null);
-            setBotSaved(
-              configNeedsSave ? false : (progress.bot_saved ?? false),
-            );
-            setMessageReceived(progress.message_received ?? false);
+            setBotSaved(progress.bot_saved ?? false);
             setSelectedRunner(progress.selected_runner);
 
             // Restore bot name from fetched bot data
             setBotName(botData.bot.name);
-            setAdapterConfig(configToRestore);
 
             // Restore webhook URLs
             const runtimeValues = botData.bot.adapter_runtime_values as
@@ -225,9 +183,7 @@ export default function WizardPage() {
                 step: 0,
                 selected_adapter: null,
                 created_bot_uuid: null,
-                created_pipeline_uuid: null,
                 bot_saved: false,
-                message_received: false,
                 selected_runner: null,
               })
               .catch(() => {});
@@ -255,9 +211,7 @@ export default function WizardPage() {
   const runnerOptions = useMemo(() => {
     if (!runnerStage) return [];
     const runnerField = runnerStage.config.find((c) => c.name === 'runner');
-    return (runnerField?.options ?? []).filter(
-      (option) => option.name !== 'local-agent',
-    );
+    return runnerField?.options ?? [];
   }, [runnerStage]);
 
   const selectedRunnerConfigStage: PipelineConfigStage | undefined =
@@ -331,20 +285,13 @@ export default function WizardPage() {
       case 0:
         return selectedAdapter !== null;
       case 1:
-        return createdBotUuid !== null && botSaved && messageReceived;
+        return createdBotUuid !== null && botSaved;
       case 2:
-        return aiChoice !== null;
+        return selectedRunner !== null;
       default:
         return false;
     }
-  }, [
-    currentStep,
-    selectedAdapter,
-    createdBotUuid,
-    botSaved,
-    messageReceived,
-    aiChoice,
-  ]);
+  }, [currentStep, selectedAdapter, createdBotUuid, botSaved, selectedRunner]);
 
   const goNext = useCallback(() => {
     if (currentStep < TOTAL_STEPS - 1 && canProceed()) {
@@ -380,17 +327,12 @@ export default function WizardPage() {
       const defaultConfig = adapter
         ? getDefaultValues(adapter.spec.config)
         : {};
-      const initialConfig = ensureHttpBotSigningSecret(
-        selectedAdapter,
-        defaultConfig,
-      );
-      setAdapterConfig(initialConfig);
 
       const bot: Bot = {
         name: defaultName,
         description: '',
         adapter: selectedAdapter,
-        adapter_config: initialConfig,
+        adapter_config: defaultConfig,
         enable: false,
       };
       const resp = await httpClient.createBot(bot);
@@ -418,9 +360,7 @@ export default function WizardPage() {
         step: 1,
         selected_adapter: selectedAdapter,
         created_bot_uuid: resp.uuid,
-        created_pipeline_uuid: null,
         bot_saved: false,
-        message_received: false,
         selected_runner: null,
       });
     } catch (err) {
@@ -434,67 +374,21 @@ export default function WizardPage() {
   }, [selectedAdapter, adapters, t, saveProgress]);
 
   // ---- Save Bot Config & Enable (Step 1) ----
-  // Creates a recommended Local Agent pipeline, binds it, and enables the bot.
+  // Updates the bot's adapter config and enables it.
 
   const handleSaveBot = useCallback(async () => {
     if (!createdBotUuid || !selectedAdapter) return;
     setIsSavingBot(true);
 
-    let createdPipelineThisAttempt: string | null = null;
     try {
-      let pipelineUuid = createdPipelineUuid;
-      if (!pipelineUuid) {
-        const recommendedModel = await httpClient.getWizardRecommendedModel();
-        const pipelineResp = await httpClient.createPipeline({
-          name: `${botName} Agent`,
-          description: botDescription || '',
-          config: {},
-        });
-        pipelineUuid = pipelineResp.uuid;
-        createdPipelineThisAttempt = pipelineUuid;
-        const createdPipeline = await httpClient.getPipeline(pipelineUuid);
-        const aiConfig = createdPipeline.pipeline.config.ai as Record<
-          string,
-          unknown
-        >;
-        const localAgentConfig = (aiConfig['local-agent'] ?? {}) as Record<
-          string,
-          unknown
-        >;
-        await httpClient.updatePipeline(pipelineUuid, {
-          name: `${botName} Agent`,
-          description: botDescription || '',
-          config: {
-            ...createdPipeline.pipeline.config,
-            ai: {
-              ...aiConfig,
-              runner: { runner: 'local-agent' },
-              'local-agent': {
-                ...localAgentConfig,
-                model: { primary: recommendedModel.uuid, fallbacks: [] },
-              },
-            },
-          },
-        });
-        setCreatedPipelineUuid(pipelineUuid);
-      }
-
-      const configToSave = ensureHttpBotSigningSecret(
-        selectedAdapter,
-        adapterConfig,
-      );
-      setAdapterConfig(configToSave);
-
       await httpClient.updateBot(createdBotUuid, {
         name: botName,
         description: botDescription || '',
         adapter: selectedAdapter,
-        adapter_config: configToSave,
+        adapter_config: adapterConfig,
         enable: true,
-        use_pipeline_uuid: pipelineUuid,
       });
       setBotSaved(true);
-      setMessageReceived(false);
 
       // Re-fetch runtime info to get updated webhook URL(s)
       try {
@@ -511,19 +405,8 @@ export default function WizardPage() {
       }
 
       // Persist progress
-      saveProgress({
-        step: 1,
-        bot_saved: true,
-        message_received: false,
-        created_pipeline_uuid: pipelineUuid,
-      });
+      saveProgress({ step: 1, bot_saved: true });
     } catch (err) {
-      if (createdPipelineThisAttempt) {
-        await httpClient
-          .deletePipeline(createdPipelineThisAttempt)
-          .catch(() => {});
-        setCreatedPipelineUuid(null);
-      }
       const apiErr = err as { msg?: string };
       toast.error(
         t('wizard.createError') + (apiErr?.msg ? `: ${apiErr.msg}` : ''),
@@ -537,80 +420,60 @@ export default function WizardPage() {
     botName,
     botDescription,
     adapterConfig,
-    createdPipelineUuid,
     t,
     saveProgress,
   ]);
 
-  const handleMessageReceived = useCallback(() => {
-    if (messageReceived) return;
-    setMessageReceived(true);
-    saveProgress({ step: 1, message_received: true });
-  }, [messageReceived, saveProgress]);
-
-  const completeWizard = useCallback(async () => {
-    await httpClient.updateWizardStatus('completed');
-    systemInfo.wizard_status = 'completed';
-    systemInfo.wizard_progress = null;
-  }, []);
-
-  // ---- Complete the optional AI Engine step ----
+  // ---- Create Pipeline & Link (Step 2 finish) ----
 
   const handleFinish = useCallback(async () => {
-    if (!aiChoice || !createdBotUuid || !createdPipelineUuid) return;
-    if (aiChoice === 'external' && !selectedRunner) return;
+    if (!selectedRunner || !createdBotUuid) return;
     setIsSubmitting(true);
-    let externalPipelineUuid: string | null = null;
-    let externalPipelineBound = false;
 
     try {
-      if (aiChoice === 'external' && selectedRunner) {
-        const pipelineResp = await httpClient.createPipeline({
-          name: `${botName} External Agent`,
-          description: botDescription || '',
-          config: {},
-        });
-        externalPipelineUuid = pipelineResp.uuid;
-        const createdPipeline = await httpClient.getPipeline(pipelineResp.uuid);
-        const fullConfig = createdPipeline.pipeline.config;
-        await httpClient.updatePipeline(pipelineResp.uuid, {
-          name: `${botName} External Agent`,
-          description: botDescription || '',
-          config: {
-            ...fullConfig,
-            ai: {
-              ...fullConfig.ai,
-              runner: { runner: selectedRunner },
-              [selectedRunner]: runnerConfig,
-            },
-          },
-        });
+      // 1. Create pipeline (backend fills config from default template)
+      const pipeline: Pipeline = {
+        name: `${botName} Pipeline`,
+        description: botDescription || '',
+        config: {},
+      };
+      const pipelineResp = await httpClient.createPipeline(pipeline);
 
-        const botData = await httpClient.getBot(createdBotUuid);
-        const existingBot = botData.bot;
-        await httpClient.updateBot(createdBotUuid, {
-          name: existingBot.name,
-          description: existingBot.description,
-          adapter: existingBot.adapter,
-          adapter_config: existingBot.adapter_config,
-          enable: existingBot.enable,
-          use_pipeline_uuid: pipelineResp.uuid,
-        });
-        externalPipelineBound = true;
-      }
+      // 2. Fetch the created pipeline to get the full default config
+      //    (includes trigger, safety, ai, output sections).
+      //    Then merge only the AI section with the wizard's runner config.
+      const createdPipeline = await httpClient.getPipeline(pipelineResp.uuid);
+      const fullConfig = createdPipeline.pipeline.config;
 
-      await completeWizard();
-      if (aiChoice === 'own-model') {
-        navigate(`/home/pipelines?id=${createdPipelineUuid}`, {
-          replace: true,
-        });
-      } else {
-        navigate('/home', { replace: true });
-      }
+      const mergedConfig = {
+        ...fullConfig,
+        ai: {
+          ...fullConfig.ai,
+          runner: { runner: selectedRunner },
+          [selectedRunner]: runnerConfig,
+        },
+      };
+
+      await httpClient.updatePipeline(pipelineResp.uuid, {
+        name: `${botName} Pipeline`,
+        description: botDescription || '',
+        config: mergedConfig,
+      });
+
+      // 3. Link pipeline to the bot created in Step 1
+      const botData = await httpClient.getBot(createdBotUuid);
+      const existingBot = botData.bot;
+      await httpClient.updateBot(createdBotUuid, {
+        name: existingBot.name,
+        description: existingBot.description,
+        adapter: existingBot.adapter,
+        adapter_config: existingBot.adapter_config,
+        enable: existingBot.enable,
+        use_pipeline_uuid: pipelineResp.uuid,
+      });
+
+      setCurrentStep(3);
     } catch (err) {
-      if (externalPipelineUuid && !externalPipelineBound) {
-        await httpClient.deletePipeline(externalPipelineUuid).catch(() => {});
-      }
       const apiErr = err as { msg?: string };
       toast.error(
         t('wizard.createError') + (apiErr?.msg ? `: ${apiErr.msg}` : ''),
@@ -621,13 +484,9 @@ export default function WizardPage() {
   }, [
     selectedRunner,
     createdBotUuid,
-    createdPipelineUuid,
-    aiChoice,
     botName,
     botDescription,
     runnerConfig,
-    completeWizard,
-    navigate,
     t,
   ]);
 
@@ -665,9 +524,7 @@ export default function WizardPage() {
         step: 0,
         selected_adapter: null,
         created_bot_uuid: null,
-        created_pipeline_uuid: null,
         bot_saved: false,
-        message_received: false,
         selected_runner: null,
       });
       systemInfo.wizard_progress = null;
@@ -695,6 +552,7 @@ export default function WizardPage() {
     t('wizard.step.platform'),
     t('wizard.step.botConfig'),
     t('wizard.step.aiEngine'),
+    t('wizard.step.done'),
   ];
 
   return (
@@ -709,7 +567,7 @@ export default function WizardPage() {
         </div>
         <div className="flex items-center gap-2">
           <LanguageSelector />
-          {currentStep < TOTAL_STEPS && (
+          {currentStep < 3 && (
             <Button
               variant="ghost"
               size="sm"
@@ -794,8 +652,6 @@ export default function WizardPage() {
             createdBotUuid={createdBotUuid}
             isSavingBot={isSavingBot}
             botSaved={botSaved}
-            messageReceived={messageReceived}
-            onMessageReceived={handleMessageReceived}
             onSaveBot={handleSaveBot}
             webhookUrl={webhookUrl}
             extraWebhookUrl={extraWebhookUrl}
@@ -804,8 +660,6 @@ export default function WizardPage() {
         {currentStep === 2 && (
           <StepAIEngine
             runnerOptions={runnerOptions}
-            choice={aiChoice}
-            onChoiceChange={setAiChoice}
             selected={selectedRunner}
             onSelect={handleSelectRunner}
             isLocalAccount={isLocalAccount}
@@ -815,10 +669,11 @@ export default function WizardPage() {
             onRunnerConfigChange={setRunnerConfig}
           />
         )}
+        {currentStep === 3 && <StepDone />}
       </div>
 
       {/* Footer navigation */}
-      {currentStep < TOTAL_STEPS && (
+      {currentStep < 3 && (
         <div className="shrink-0 flex justify-between items-center px-4 sm:px-6 py-3 sm:py-4 border-t">
           <Button
             variant="outline"
@@ -848,20 +703,12 @@ export default function WizardPage() {
           ) : (
             <Button
               onClick={handleFinish}
-              disabled={
-                !canProceed() ||
-                isSubmitting ||
-                (aiChoice === 'external' && !selectedRunner)
-              }
+              disabled={!canProceed() || isSubmitting}
             >
               {isSubmitting && (
                 <Loader2 className="w-4 h-4 mr-1.5 animate-spin" />
               )}
-              {aiChoice === 'external'
-                ? t('wizard.aiEngine.createExternal')
-                : aiChoice === 'own-model'
-                  ? t('wizard.aiEngine.configurePipeline')
-                  : t('wizard.aiEngine.openWorkbench')}
+              {t('wizard.finish')}
             </Button>
           )}
         </div>
@@ -1002,35 +849,6 @@ function StepPlatform({
 // Step 1: Bot Configuration + Logs
 // ---------------------------------------------------------------------------
 
-function PageBotFloatingWidget({
-  botUuid,
-  title,
-}: {
-  botUuid: string;
-  title?: string;
-}) {
-  useEffect(() => {
-    const script = document.createElement('script');
-    script.src = `${window.location.origin}/api/v1/embed/${botUuid}/widget.js`;
-    script.dataset.title = title || 'LangBot';
-    document.body.appendChild(script);
-
-    return () => {
-      script.remove();
-      const root = document.getElementById('langbot-widget-root') as
-        | (HTMLElement & { langbotDestroy?: () => void })
-        | null;
-      if (root?.langbotDestroy) {
-        root.langbotDestroy();
-      } else {
-        root?.remove();
-      }
-    };
-  }, [botUuid, title]);
-
-  return null;
-}
-
 function StepBotConfig({
   adapterConfigItems,
   adapterConfigValues,
@@ -1040,8 +858,6 @@ function StepBotConfig({
   createdBotUuid,
   isSavingBot,
   botSaved,
-  messageReceived,
-  onMessageReceived,
   onSaveBot,
   webhookUrl,
   extraWebhookUrl,
@@ -1054,17 +870,11 @@ function StepBotConfig({
   createdBotUuid: string | null;
   isSavingBot: boolean;
   botSaved: boolean;
-  messageReceived: boolean;
-  onMessageReceived: () => void;
   onSaveBot: () => void;
   webhookUrl: string;
   extraWebhookUrl: string;
 }) {
   const { t } = useTranslation();
-  const [testMessage, setTestMessage] = useState(
-    t('wizard.botConfig.httpTestDefaultMessage'),
-  );
-  const [isSendingTest, setIsSendingTest] = useState(false);
 
   const adapterLabel = useMemo(() => {
     const a = adapters.find((ad) => ad.name === selectedAdapterName);
@@ -1079,42 +889,8 @@ function StepBotConfig({
     [],
   );
 
-  const copyWebhookUrl = useCallback(async () => {
-    if (!webhookUrl) return;
-    await navigator.clipboard.writeText(webhookUrl);
-    toast.success(t('common.copySuccess'));
-  }, [t, webhookUrl]);
-
-  const sendHttpBotTest = useCallback(async () => {
-    if (!createdBotUuid || !testMessage.trim()) return;
-    setIsSendingTest(true);
-    try {
-      await httpClient.testHttpBotInbound(createdBotUuid, testMessage.trim());
-      toast.success(t('wizard.botConfig.httpTestAccepted'));
-    } catch (error) {
-      toast.error(
-        t('wizard.botConfig.httpTestFailed', {
-          error: getErrorMessage(error),
-        }),
-      );
-    } finally {
-      setIsSendingTest(false);
-    }
-  }, [createdBotUuid, testMessage, t]);
-
   return (
     <div className="max-w-5xl mx-auto space-y-6">
-      {selectedAdapterName === 'web_page_bot' && botSaved && createdBotUuid && (
-        <PageBotFloatingWidget
-          botUuid={createdBotUuid}
-          title={
-            typeof adapterConfigValues.title === 'string'
-              ? adapterConfigValues.title
-              : undefined
-          }
-        />
-      )}
-
       <div className="text-center">
         <h2 className="text-xl font-semibold">{t('wizard.botConfig.title')}</h2>
         <p className="text-sm text-muted-foreground mt-1">
@@ -1122,104 +898,6 @@ function StepBotConfig({
         </p>
       </div>
 
-      {botSaved && (
-        <div
-          className={cn(
-            'border px-4 py-3',
-            messageReceived
-              ? 'border-green-200 bg-green-50 dark:border-green-800 dark:bg-green-950/30'
-              : 'border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950/30',
-          )}
-        >
-          <div className="flex items-start gap-3">
-            <div
-              className={cn(
-                'mt-0.5 flex size-5 shrink-0 items-center justify-center rounded-full',
-                messageReceived ? 'bg-green-500' : 'bg-amber-500',
-              )}
-            >
-              {messageReceived ? (
-                <Check className="size-3 text-white" />
-              ) : selectedAdapterName === 'web_page_bot' ? (
-                <MessageSquare className="size-3 text-white" />
-              ) : selectedAdapterName === 'http_bot' ? (
-                <Send className="size-3 text-white" />
-              ) : webhookUrl ? (
-                <Webhook className="size-3 text-white" />
-              ) : (
-                <Loader2 className="size-3 animate-spin text-white" />
-              )}
-            </div>
-            <div className="min-w-0 flex-1">
-              <p
-                className={cn(
-                  'text-sm font-medium',
-                  messageReceived
-                    ? 'text-green-800 dark:text-green-200'
-                    : 'text-amber-800 dark:text-amber-200',
-                )}
-              >
-                {messageReceived
-                  ? t('wizard.botConfig.messageReceived')
-                  : selectedAdapterName === 'web_page_bot'
-                    ? t('wizard.botConfig.pageBotTestPrompt')
-                    : selectedAdapterName === 'http_bot'
-                      ? t('wizard.botConfig.httpTestPrompt')
-                      : webhookUrl
-                        ? t('wizard.botConfig.webhookTestPrompt')
-                        : t('wizard.botConfig.waitingForMessage')}
-              </p>
-
-              {!messageReceived && webhookUrl && (
-                <div className="mt-3 space-y-3">
-                  <div className="flex items-center gap-2">
-                    <code className="min-w-0 flex-1 overflow-hidden text-ellipsis whitespace-nowrap border bg-background px-2.5 py-2 text-xs">
-                      {webhookUrl}
-                    </code>
-                    <Button
-                      type="button"
-                      variant="outline"
-                      size="icon"
-                      className="size-9 shrink-0"
-                      onClick={copyWebhookUrl}
-                      title={t('common.copy')}
-                    >
-                      <Copy className="size-4" />
-                    </Button>
-                  </div>
-
-                  {selectedAdapterName === 'http_bot' && (
-                    <div className="flex flex-col gap-2 sm:flex-row">
-                      <Input
-                        value={testMessage}
-                        onChange={(event) => setTestMessage(event.target.value)}
-                        onKeyDown={(event) => {
-                          if (event.key === 'Enter') void sendHttpBotTest();
-                        }}
-                        className="bg-background"
-                      />
-                      <Button
-                        type="button"
-                        onClick={() => void sendHttpBotTest()}
-                        disabled={isSendingTest || !testMessage.trim()}
-                        className="shrink-0"
-                      >
-                        {isSendingTest ? (
-                          <Loader2 className="mr-1.5 size-4 animate-spin" />
-                        ) : (
-                          <Send className="mr-1.5 size-4" />
-                        )}
-                        {t('wizard.botConfig.sendHttpTest')}
-                      </Button>
-                    </div>
-                  )}
-                </div>
-              )}
-            </div>
-          </div>
-        </div>
-      )}
-
       <div className="grid gap-6 grid-cols-1 lg:grid-cols-2">
         {/* Left column: Adapter config form */}
         <div className="space-y-4">
@@ -1283,6 +961,18 @@ function StepBotConfig({
               </CardContent>
             </Card>
           )}
+
+          {/* Bot saved indicator */}
+          {botSaved && (
+            <div className="flex items-center gap-2 px-4 py-3 rounded-lg border border-green-200 bg-green-50 dark:border-green-800 dark:bg-green-950/30">
+              <div className="w-5 h-5 rounded-full bg-green-500 flex items-center justify-center shrink-0">
+                <Check className="w-3 h-3 text-white" />
+              </div>
+              <span className="text-sm text-green-700 dark:text-green-300">
+                {t('wizard.botConfig.botSaved')}
+              </span>
+            </div>
+          )}
         </div>
 
         {/* Right column: Bot logs */}
@@ -1299,7 +989,6 @@ function StepBotConfig({
                 botId={createdBotUuid}
                 autoExpandImages
                 hideToolbar
-                onMessageReceived={onMessageReceived}
               />
             </CardContent>
           </Card>
@@ -1315,8 +1004,6 @@ function StepBotConfig({
 
 function StepAIEngine({
   runnerOptions,
-  choice,
-  onChoiceChange,
   selected,
   onSelect,
   isLocalAccount,
@@ -1326,10 +1013,6 @@ function StepAIEngine({
   onRunnerConfigChange,
 }: {
   runnerOptions: { name: string; label: { en_US: string; zh_Hans: string } }[];
-  choice: 'external' | 'own-model' | 'more-features' | null;
-  onChoiceChange: (
-    choice: 'external' | 'own-model' | 'more-features' | null,
-  ) => void;
   selected: string | null;
   onSelect: (name: string) => void;
   isLocalAccount: boolean;
@@ -1353,63 +1036,6 @@ function StepAIEngine({
     return r ? extractI18nObject(r.label) : (selected ?? '');
   }, [runnerOptions, selected]);
 
-  const choices = [
-    {
-      id: 'external' as const,
-      icon: Cable,
-      title: t('wizard.aiEngine.externalTitle'),
-      description: t('wizard.aiEngine.externalDescription'),
-    },
-    {
-      id: 'own-model' as const,
-      icon: Settings2,
-      title: t('wizard.aiEngine.ownModelTitle'),
-      description: t('wizard.aiEngine.ownModelDescription'),
-    },
-    {
-      id: 'more-features' as const,
-      icon: Blocks,
-      title: t('wizard.aiEngine.moreFeaturesTitle'),
-      description: t('wizard.aiEngine.moreFeaturesDescription'),
-    },
-  ];
-
-  if (choice !== 'external') {
-    return (
-      <div className="space-y-6 max-w-4xl mx-auto">
-        <div className="text-center">
-          <h2 className="text-xl font-semibold">
-            {t('wizard.aiEngine.title')}
-          </h2>
-          <p className="text-sm text-muted-foreground mt-1">
-            {t('wizard.aiEngine.optionalDescription')}
-          </p>
-        </div>
-        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-          {choices.map((item) => {
-            const Icon = item.icon;
-            return (
-              <Card
-                key={item.id}
-                className={cn(
-                  'cursor-pointer transition-all hover:border-primary/50',
-                  choice === item.id && 'ring-2 ring-primary',
-                )}
-                onClick={() => onChoiceChange(item.id)}
-              >
-                <CardHeader>
-                  <Icon className="size-6 text-primary" />
-                  <CardTitle className="text-base">{item.title}</CardTitle>
-                  <CardDescription>{item.description}</CardDescription>
-                </CardHeader>
-              </Card>
-            );
-          })}
-        </div>
-      </div>
-    );
-  }
-
   // Before any runner is selected: centered grid layout
   if (!selected) {
     return (
@@ -1419,13 +1045,9 @@ function StepAIEngine({
             {t('wizard.aiEngine.title')}
           </h2>
           <p className="text-sm text-muted-foreground mt-1">
-            {t('wizard.aiEngine.runnerDescription')}
+            {t('wizard.aiEngine.description')}
           </p>
         </div>
-        <Button variant="ghost" size="sm" onClick={() => onChoiceChange(null)}>
-          <ArrowLeft className="size-4 mr-1.5" />
-          {t('wizard.aiEngine.backToChoices')}
-        </Button>
         <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
           {runnerOptions.map((opt) => (
             <Card
@@ -1462,16 +1084,6 @@ function StepAIEngine({
         </p>
       </div>
 
-      <Button
-        variant="ghost"
-        size="sm"
-        className="self-start mb-3"
-        onClick={() => onChoiceChange(null)}
-      >
-        <ArrowLeft className="size-4 mr-1.5" />
-        {t('wizard.aiEngine.backToChoices')}
-      </Button>
-
       <div className="flex flex-col lg:flex-row lg:justify-center gap-6 lg:flex-1 lg:min-h-0 animate-in fade-in slide-in-from-bottom-2 duration-300">
         {/* Left: runner list */}
         <div className="w-full lg:w-[280px] shrink-0 lg:overflow-y-auto lg:pr-3">
@@ -1567,3 +1179,100 @@ function StepAIEngine({
     </div>
   );
 }
+
+// ---------------------------------------------------------------------------
+// Step 3: Done
+// ---------------------------------------------------------------------------
+
+function StepDone() {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+
+  const [particles] = useState(() =>
+    Array.from({ length: 30 }, (_, i) => ({
+      id: i,
+      left: Math.random() * 100,
+      delay: Math.random() * 2,
+      duration: 2 + Math.random() * 2,
+      size: 4 + Math.random() * 6,
+      color: [
+        'bg-purple-400',
+        'bg-pink-400',
+        'bg-orange-400',
+        'bg-blue-400',
+        'bg-green-400',
+        'bg-yellow-400',
+      ][Math.floor(Math.random() * 6)],
+    })),
+  );
+
+  const [isCompleting, setIsCompleting] = useState(false);
+
+  const handleBack = useCallback(async () => {
+    setIsCompleting(true);
+    try {
+      if (systemInfo.wizard_status === 'none') {
+        await httpClient.updateWizardStatus('completed');
+        systemInfo.wizard_status = 'completed';
+      }
+      // Always clear persisted progress so re-entering starts fresh
+      await httpClient.saveWizardProgress({
+        step: 0,
+        selected_adapter: null,
+        created_bot_uuid: null,
+        bot_saved: false,
+        selected_runner: null,
+      });
+      systemInfo.wizard_progress = null;
+    } catch {
+      toast.error(t('wizard.completeSaveError'));
+      setIsCompleting(false);
+      return;
+    }
+    setIsCompleting(false);
+    navigate('/home/bots');
+  }, [navigate, t]);
+
+  return (
+    <div className="relative flex flex-col items-center justify-center h-full min-h-[400px]">
+      {/* Confetti particles */}
+      <div className="absolute inset-0 overflow-hidden pointer-events-none">
+        {particles.map((p) => (
+          <div
+            key={p.id}
+            className={cn('absolute rounded-full opacity-0', p.color)}
+            style={{
+              left: `${p.left}%`,
+              width: p.size,
+              height: p.size,
+              animation: `wizardConfetti ${p.duration}s ease-out ${p.delay}s forwards`,
+            }}
+          />
+        ))}
+      </div>
+
+      <PartyPopper className="w-16 h-16 text-primary mb-4" />
+      <h2 className="text-2xl font-bold">{t('wizard.done.title')}</h2>
+      <p className="text-muted-foreground mt-2 text-center max-w-md">
+        {t('wizard.done.description')}
+      </p>
+      <Button className="mt-6" onClick={handleBack} disabled={isCompleting}>
+        {isCompleting && <Loader2 className="w-4 h-4 mr-1.5 animate-spin" />}
+        {t('wizard.done.backToWorkbench')}
+      </Button>
+
+      <style>{`
+        @keyframes wizardConfetti {
+          0% {
+            transform: translateY(100vh) rotate(0deg);
+            opacity: 1;
+          }
+          100% {
+            transform: translateY(-20vh) rotate(720deg);
+            opacity: 0;
+          }
+        }
+      `}</style>
+    </div>
+  );
+}

web/src/app/wizard/utils.ts

@@ -1,36 +0,0 @@
-export function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message;
-
-  if (typeof error === 'object' && error !== null && 'msg' in error) {
-    const message = (error as { msg?: unknown }).msg;
-    if (typeof message === 'string') return message;
-  }
-
-  return String(error);
-}
-
-function createSigningSecret(): string {
-  const bytes = new Uint8Array(32);
-  crypto.getRandomValues(bytes);
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join(
-    '',
-  );
-}
-
-export function ensureHttpBotSigningSecret(
-  adapterName: string,
-  config: Record<string, unknown>,
-): Record<string, unknown> {
-  if (
-    adapterName !== 'http_bot' ||
-    config.signature_required === false ||
-    (typeof config.inbound_secret === 'string' && config.inbound_secret)
-  ) {
-    return config;
-  }
-
-  return {
-    ...config,
-    inbound_secret: createSigningSecret(),
-  };
-}

web/src/i18n/locales/en-US.ts

@@ -372,6 +372,10 @@ const enUS = {
     log: 'Log',
     configuration: 'Configuration',
     logs: 'Logs',
+    runtimeConnected: 'Connected',
+    runtimeConnecting: 'Connecting',
+    runtimeDisconnected: 'Disconnected',
+    runtimeError: 'Connection error',
     basicInfo: 'Basic Information',
     basicInfoDescription: 'Set the bot name and description',
     routingConnection: 'Routing & Connection',
@@ -1827,23 +1831,6 @@ const enUS = {
       resaveBot: 'Re-save Configuration',
       botSaved:
         'Bot configuration saved and enabled. Check the logs to verify the connection.',
-      waitingForMessage:
-        'The bot is enabled. Send it a message from your IM platform to continue.',
-      messageReceived:
-        'The bot received an IM message. You can continue to the next step.',
-      pageBotTestPrompt:
-        'Page Bot is enabled. Click the chat bubble in the lower-right corner and send a message to verify the full conversation flow.',
-      webhookTestPrompt:
-        'The callback URL is ready. Configure it on the external platform, then send the bot a real message.',
-      httpTestPrompt:
-        'HTTP Bot is enabled. Send a real inbound message here to verify the connection.',
-      httpTestDefaultMessage: 'Hello, this is a connection test message.',
-      sendHttpTest: 'Send Test Message',
-      httpTestAccepted:
-        'The test message was accepted. It will appear in the log shortly.',
-      httpTestMissingSecret:
-        'Enter an inbound signing secret and save the configuration first.',
-      httpTestFailed: 'Failed to send the test message: {{error}}',
       logsTitle: 'Bot Logs',
       logsDescription:
         'Monitor bot activity to verify the platform connection is working.',
@@ -1852,23 +1839,6 @@ const enUS = {
       title: 'Select an AI Engine',
       description:
         "Choose the AI engine that will power your bot's intelligence.",
-      optionalDescription:
-        'This step is optional. Choose how you want to continue with the current agent.',
-      externalTitle: 'Connect an External Agent',
-      externalDescription:
-        'Connect Dify, n8n, Coze, or another platform and replace the bot pipeline.',
-      ownModelTitle: 'Use My Own Model',
-      ownModelDescription:
-        'Open the current Local Agent pipeline and configure your own model.',
-      moreFeaturesTitle: 'Add More Agent Features',
-      moreFeaturesDescription:
-        'Open the workbench to add tools, knowledge, and other capabilities.',
-      runnerDescription:
-        'Select a runner for the external agent and configure its connection.',
-      backToChoices: 'Back to options',
-      createExternal: 'Create and Bind',
-      configurePipeline: 'Configure Pipeline',
-      openWorkbench: 'Open Workbench',
     },
     spaceBanner: {
       message:
@@ -1955,6 +1925,19 @@ const enUS = {
       'Scan the QR code below with WeChat to authorize and automatically fill in the token',
     loginSuccess: 'Login successful! Token has been filled in',
     loginFailed: 'Login failed',
+    connecting: 'Connecting to WeChat service...',
+    waitingForScan: 'Waiting for scan',
+    retry: 'Retry',
+  },
+  itchat: {
+    scanLogin: 'Scan QR Login',
+    scanQRCode: 'Scan the QR code below with WeChat to login',
+    loginSuccess:
+      'Login successful! Session cached. Save config to start using.',
+    loginFailed: 'Login failed',
+    connecting: 'Starting WeChat login...',
+    waitingForScan: 'Waiting for scan',
+    retry: 'Retry',
   },
   dingtalk: {
     createApp: 'One-Click Create DingTalk App',

web/src/i18n/locales/es-ES.ts

@@ -220,6 +220,19 @@ const esES = {
     selectModelAbilities: 'Seleccionar capacidades del modelo',
     visionAbility: 'Capacidad de visión',
     functionCallAbility: 'Llamada a funciones',
+    reasoningAbility: 'Razonamiento',
+    reasoningLevel: 'Nivel de razonamiento',
+    reasoningLevels: {
+      providerDefault: 'Predeterminado del proveedor',
+      disabled: 'Desactivado',
+      enabled: 'Activado',
+      minimal: 'Mínimo',
+      low: 'Bajo',
+      medium: 'Medio',
+      high: 'Alto',
+      xhigh: 'Extra alto',
+      max: 'Máximo',
+    },
     contextLength: 'Ventana de contexto',
     contextLengthPlaceholder: 'Desconocido',
     contextLengthInvalid: 'La ventana de contexto debe ser un entero positivo',
@@ -1747,6 +1760,9 @@ const esES = {
     loginSuccess:
       '¡Inicio de sesión correcto! El token se ha rellenado automáticamente',
     loginFailed: 'Error al iniciar sesión',
+    connecting: 'Conectando con el servicio de WeChat...',
+    waitingForScan: 'Esperando escaneo',
+    retry: 'Reintentar',
   },
   dingtalk: {
     createApp: 'Crear aplicación de DingTalk con un clic',

web/src/i18n/locales/ja-JP.ts

@@ -378,6 +378,10 @@ const jaJP = {
     log: 'ログ',
     configuration: '設定',
     logs: 'ログ',
+    runtimeConnected: '接続済み',
+    runtimeConnecting: '接続中',
+    runtimeDisconnected: '切断済み',
+    runtimeError: '接続エラー',
     basicInfo: '基本情報',
     basicInfoDescription: 'ボットの名前と説明を設定',
     routingConnection: 'ルーティングと接続',
@@ -1744,23 +1748,6 @@ const jaJP = {
       resaveBot: '設定を再保存',
       botSaved:
         'ボット設定が保存され、有効になりました。ログを確認して接続を検証してください。',
-      waitingForMessage:
-        'ボットが有効になりました。続行するには IM からメッセージを送信してください。',
-      messageReceived:
-        'ボットが IM メッセージを受信しました。次のステップに進めます。',
-      pageBotTestPrompt:
-        'ページボットが有効になりました。右下のチャットバブルをクリックしてメッセージを送信し、会話フロー全体を確認してください。',
-      webhookTestPrompt:
-        'コールバック URL の準備ができました。外部プラットフォームに設定し、ボットへ実際のメッセージを送信してください。',
-      httpTestPrompt:
-        'HTTP Bot が有効になりました。実際の受信メッセージを送信して接続を確認できます。',
-      httpTestDefaultMessage: 'こんにちは。これは接続テストメッセージです。',
-      sendHttpTest: 'テストメッセージを送信',
-      httpTestAccepted:
-        'テストメッセージを受け付けました。まもなくログに表示されます。',
-      httpTestMissingSecret:
-        '受信署名シークレットを入力し、先に設定を保存してください。',
-      httpTestFailed: 'テストメッセージの送信に失敗しました：{{error}}',
       logsTitle: 'ボットログ',
       logsDescription:
         'ボットの活動を監視して、プラットフォーム接続が正常に動作していることを確認します。',
@@ -1769,22 +1756,6 @@ const jaJP = {
       title: 'AIエンジンを選択',
       description:
         'ボットのインテリジェンスを駆動するAIエンジンを選択してください。',
-      optionalDescription:
-        'このステップは任意です。現在の Agent をどのように設定するか選択してください。',
-      externalTitle: '外部プラットフォームの Agent を接続',
-      externalDescription:
-        'Dify、n8n、Coze などを接続し、ボットのパイプラインを置き換えます。',
-      ownModelTitle: '自分のモデルを使用',
-      ownModelDescription:
-        '現在の Local Agent パイプラインを開き、自分のモデルを設定します。',
-      moreFeaturesTitle: 'Agent に機能を追加',
-      moreFeaturesDescription:
-        'ワークベンチを開き、ツールやナレッジなどの機能を追加します。',
-      runnerDescription: '外部 Agent の Runner を選択し、接続を設定します。',
-      backToChoices: '選択肢に戻る',
-      createExternal: '作成して関連付ける',
-      configurePipeline: 'パイプラインを設定',
-      openWorkbench: 'ワークベンチを開く',
     },
     spaceBanner: {
       message:
@@ -1870,6 +1841,9 @@ const jaJP = {
     scanQRCode: '以下のQRコードをWeChatでスキャンし、トークンを自動入力',
     loginSuccess: 'ログイン成功！トークンが自動入力されました',
     loginFailed: 'ログイン失敗',
+    connecting: 'WeChatサービスに接続中...',
+    waitingForScan: 'スキャン待ち',
+    retry: '再試行',
   },
   dingtalk: {
     createApp: 'ワンクリックでDingTalkアプリ作成',

web/src/i18n/locales/ru-RU.ts

@@ -217,6 +217,19 @@ const ruRU = {
     selectModelAbilities: 'Выберите возможности модели',
     visionAbility: 'Распознавание изображений',
     functionCallAbility: 'Вызов функций',
+    reasoningAbility: 'Рассуждение',
+    reasoningLevel: 'Уровень рассуждений',
+    reasoningLevels: {
+      providerDefault: 'По умолчанию провайдера',
+      disabled: 'Выключено',
+      enabled: 'Включено',
+      minimal: 'Минимальный',
+      low: 'Низкий',
+      medium: 'Средний',
+      high: 'Высокий',
+      xhigh: 'Очень высокий',
+      max: 'Максимальный',
+    },
     contextLength: 'Контекстное окно',
     contextLengthPlaceholder: 'Неизвестно',
     contextLengthInvalid:
@@ -1717,6 +1730,9 @@ const ruRU = {
       'Отсканируйте QR-код ниже в WeChat, чтобы авторизоваться и автоматически заполнить токен',
     loginSuccess: 'Вход выполнен успешно! Токен заполнен автоматически',
     loginFailed: 'Не удалось выполнить вход',
+    connecting: 'Подключение к сервису WeChat...',
+    waitingForScan: 'Ожидание сканирования',
+    retry: 'Повторить',
   },
   dingtalk: {
     createApp: 'Создать приложение DingTalk в один клик',

web/src/i18n/locales/th-TH.ts

@@ -213,6 +213,19 @@ const thTH = {
     selectModelAbilities: 'เลือกความสามารถของโมเดล',
     visionAbility: 'ความสามารถด้านภาพ',
     functionCallAbility: 'การเรียกฟังก์ชัน',
+    reasoningAbility: 'ความสามารถในการให้เหตุผล',
+    reasoningLevel: 'ระดับการให้เหตุผล',
+    reasoningLevels: {
+      providerDefault: 'ค่าเริ่มต้นของผู้ให้บริการ',
+      disabled: 'ปิด',
+      enabled: 'เปิด',
+      minimal: 'ต่ำสุด',
+      low: 'ต่ำ',
+      medium: 'ปานกลาง',
+      high: 'สูง',
+      xhigh: 'สูงมาก',
+      max: 'สูงสุด',
+    },
     contextLength: 'หน้าต่างบริบท',
     contextLengthPlaceholder: 'ไม่ทราบ',
     contextLengthInvalid: 'หน้าต่างบริบทต้องเป็นจำนวนเต็มบวก',
@@ -1680,6 +1693,9 @@ const thTH = {
       'สแกนคิวอาร์โค้ดด้านล่างด้วย WeChat เพื่ออนุญาตและกรอกโทเคนอัตโนมัติ',
     loginSuccess: 'เข้าสู่ระบบสำเร็จ และกรอกโทเคนอัตโนมัติแล้ว',
     loginFailed: 'เข้าสู่ระบบไม่สำเร็จ',
+    connecting: 'กำลังเชื่อมต่อบริการ WeChat...',
+    waitingForScan: 'กำลังรอการสแกน',
+    retry: 'ลองอีกครั้ง',
   },
   dingtalk: {
     createApp: 'สร้างแอป DingTalk ด้วยคลิกเดียว',

web/src/i18n/locales/vi-VN.ts

@@ -217,6 +217,19 @@ const viVN = {
     selectModelAbilities: 'Chọn khả năng mô hình',
     visionAbility: 'Khả năng thị giác',
     functionCallAbility: 'Gọi hàm',
+    reasoningAbility: 'Khả năng suy luận',
+    reasoningLevel: 'Mức độ suy luận',
+    reasoningLevels: {
+      providerDefault: 'Mặc định của nhà cung cấp',
+      disabled: 'Tắt',
+      enabled: 'Bật',
+      minimal: 'Tối thiểu',
+      low: 'Thấp',
+      medium: 'Trung bình',
+      high: 'Cao',
+      xhigh: 'Rất cao',
+      max: 'Tối đa',
+    },
     contextLength: 'Cửa sổ ngữ cảnh',
     contextLengthPlaceholder: 'Không rõ',
     contextLengthInvalid: 'Cửa sổ ngữ cảnh phải là số nguyên dương',
@@ -1708,6 +1721,9 @@ const viVN = {
       'Quét mã QR bên dưới bằng WeChat để ủy quyền và tự động điền token',
     loginSuccess: 'Đăng nhập thành công! Token đã được điền tự động',
     loginFailed: 'Đăng nhập thất bại',
+    connecting: 'Đang kết nối tới dịch vụ WeChat...',
+    waitingForScan: 'Đang chờ quét mã',
+    retry: 'Thử lại',
   },
   dingtalk: {
     createApp: 'Tạo ứng dụng DingTalk chỉ với một lần nhấp',

web/src/i18n/locales/zh-Hans.ts

@@ -355,6 +355,10 @@ const zhHans = {
     log: '日志',
     configuration: '配置',
     logs: '日志',
+    runtimeConnected: '已连接',
+    runtimeConnecting: '连接中',
+    runtimeDisconnected: '已掉线',
+    runtimeError: '连接错误',
     basicInfo: '基础信息',
     basicInfoDescription: '设置机器人名称和描述',
     routingConnection: '路由与连接',
@@ -1749,37 +1753,12 @@ const zhHans = {
       saveBot: '保存并启用',
       resaveBot: '重新保存配置',
       botSaved: '机器人配置已保存并启用，请查看日志确认连接正常。',
-      waitingForMessage: '机器人已启用。请在 IM 中向机器人发送一条消息以继续。',
-      messageReceived: '机器人已成功收到 IM 消息，可以进入下一步。',
-      pageBotTestPrompt:
-        '页面机器人已启用。点击右下角聊天气泡并发送一条消息，验证完整对话链路。',
-      webhookTestPrompt:
-        '回调地址已就绪。将它配置到外部平台，然后向机器人发送一条真实消息。',
-      httpTestPrompt: 'HTTP Bot 已启用。可直接发送一条真实入站消息验证连接。',
-      httpTestDefaultMessage: '你好，这是一条连接测试消息。',
-      sendHttpTest: '发送测试消息',
-      httpTestAccepted: '测试消息已被机器人接收，请稍候查看日志。',
-      httpTestMissingSecret: '请先填写入站签名密钥并重新保存。',
-      httpTestFailed: '测试消息发送失败：{{error}}',
       logsTitle: '机器人日志',
       logsDescription: '监控机器人活动，确认平台连接是否正常工作。',
     },
     aiEngine: {
       title: '选择 AI 引擎',
       description: '选择驱动机器人智能的 AI 引擎。',
-      optionalDescription: '这一步可选。选择接下来要如何完善当前 Agent。',
-      externalTitle: '接入外部平台 Agent',
-      externalDescription:
-        '接入 Dify、n8n、Coze 等平台，并替换当前机器人的流水线。',
-      ownModelTitle: '改成使用自己的模型',
-      ownModelDescription: '进入当前 Local Agent 流水线，配置你自己的模型。',
-      moreFeaturesTitle: '给现在的 Agent 配置更多功能',
-      moreFeaturesDescription: '进入工作台，为 Agent 添加工具、知识库等能力。',
-      runnerDescription: '选择外部 Agent 的 Runner 并完成连接配置。',
-      backToChoices: '返回选项',
-      createExternal: '创建并绑定',
-      configurePipeline: '配置流水线',
-      openWorkbench: '进入工作台',
     },
     spaceBanner: {
       message: '接入 LangBot Space，获取免费试用模型额度，零配置极速开箱！',
@@ -1859,6 +1838,18 @@ const zhHans = {
     scanQRCode: '请使用微信扫描以下二维码，授权后将自动登录并填写令牌',
     loginSuccess: '登录成功！令牌已自动填入',
     loginFailed: '登录失败',
+    connecting: '正在连接微信服务...',
+    waitingForScan: '等待扫码中',
+    retry: '重试',
+  },
+  itchat: {
+    scanLogin: '扫码登录微信',
+    scanQRCode: '请使用微信扫描以下二维码登录',
+    loginSuccess: '登录成功！会话已缓存，保存配置后即可使用',
+    loginFailed: '登录失败',
+    connecting: '正在启动微信登录...',
+    waitingForScan: '等待扫码中',
+    retry: '重试',
   },
   dingtalk: {
     createApp: '一键创建钉钉应用',

web/src/i18n/locales/zh-Hant.ts

@@ -205,6 +205,19 @@ const zhHant = {
     selectModelAbilities: '選擇模型能力',
     visionAbility: '視覺能力',
     functionCallAbility: '函數呼叫',
+    reasoningAbility: '思考能力',
+    reasoningLevel: '思考等級',
+    reasoningLevels: {
+      providerDefault: '供應商預設',
+      disabled: '關閉',
+      enabled: '開啟',
+      minimal: '最低',
+      low: '低',
+      medium: '中',
+      high: '高',
+      xhigh: '極高',
+      max: '最大',
+    },
     contextLength: '上下文視窗',
     contextLengthPlaceholder: '未知',
     contextLengthInvalid: '上下文視窗必須是正整數',
@@ -1657,6 +1670,9 @@ const zhHant = {
     scanQRCode: '請使用微信掃描以下 QR Code，授權後將自動登入並填寫令牌',
     loginSuccess: '登入成功！令牌已自動填入',
     loginFailed: '登入失敗',
+    connecting: '正在連接微信服務...',
+    waitingForScan: '等待掃碼中',
+    retry: '重試',
   },
   dingtalk: {
     createApp: '一鍵建立釘釘應用',

web/tests/unit/qr-code-login-workspace.test.mjs

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+const root = process.cwd();
+const dialogPath = path.join(
+  root,
+  'src/app/home/components/qrcode-login/QrCodeLoginDialog.tsx',
+);
+const localeDir = path.join(root, 'src/i18n/locales');
+
+const dialogSource = fs.readFileSync(dialogPath, 'utf8');
+
+test('QR credential exchanges preserve the active Workspace scope', () => {
+  assert.match(dialogSource, /getActiveWorkspaceUuid/);
+  assert.match(
+    dialogSource,
+    /sessionWorkspaceUuidRef\.current = workspaceUuid/,
+  );
+  assert.match(
+    dialogSource,
+    /const workspaceUuid = sessionWorkspaceUuidRef\.current/,
+  );
+  assert.match(dialogSource, /sessionApiBaseRef\.current = cfg\.apiBase/);
+  assert.match(
+    dialogSource,
+    /`\$\{baseUrlRef\.current\}\$\{sessionApiBaseRef\.current\}\/\$\{sessionIdRef\.current\}`/,
+  );
+  assert.match(dialogSource, /'X-Workspace-Id': workspaceUuid/);
+
+  const workspaceHeaderUses = dialogSource.match(
+    /'X-Workspace-Id': workspaceUuid/g,
+  );
+  assert.equal(
+    workspaceHeaderUses?.length,
+    4,
+    'start, poll, expiry cleanup, and dialog cleanup must all retain Workspace scope',
+  );
+});
+
+test('WeChat QR login never reuses Feishu progress copy', () => {
+  const weixinConfig = dialogSource.match(
+    /weixin:\s*\{[\s\S]*?apiBase:\s*'\/api\/v1\/platform\/adapters\/weixin\/login'/,
+  )?.[0];
+  assert.ok(weixinConfig, 'WeChat platform config is missing');
+  assert.match(weixinConfig, /connectingKey:\s*'weixin\.connecting'/);
+  assert.match(weixinConfig, /waitingKey:\s*'weixin\.waitingForScan'/);
+  assert.match(weixinConfig, /retryKey:\s*'weixin\.retry'/);
+  assert.doesNotMatch(weixinConfig, /feishu\./);
+
+  for (const locale of [
+    'en-US.ts',
+    'es-ES.ts',
+    'ja-JP.ts',
+    'ru-RU.ts',
+    'th-TH.ts',
+    'vi-VN.ts',
+    'zh-Hans.ts',
+    'zh-Hant.ts',
+  ]) {
+    const source = fs.readFileSync(path.join(localeDir, locale), 'utf8');
+    const block = source.match(/weixin:\s*\{[\s\S]*?\n\s*\},/)?.[0];
+    assert.ok(block, `${locale} is missing the WeChat locale block`);
+    for (const key of ['connecting', 'waitingForScan', 'retry']) {
+      assert.match(
+        block,
+        new RegExp(`\\b${key}:`),
+        `${locale} is missing weixin.${key}`,
+      );
+    }
+  }
+});

web/tests/unit/wizard-http-bot.test.mjs

@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-import ts from 'typescript';
-import { fileURLToPath } from 'node:url';
-
-const currentDirectory = path.dirname(fileURLToPath(import.meta.url));
-const sourcePath = path.resolve(
-  currentDirectory,
-  '../../src/app/wizard/utils.ts',
-);
-
-function loadWizardUtils() {
-  const source = fs.readFileSync(sourcePath, 'utf8');
-  const compiled = ts.transpileModule(source, {
-    compilerOptions: { module: ts.ModuleKind.CommonJS },
-  }).outputText;
-  const loadedModule = { exports: {} };
-  new Function('require', 'module', 'exports', compiled)(
-    () => {
-      throw new Error('Wizard utils must not have runtime imports');
-    },
-    loadedModule,
-    loadedModule.exports,
-  );
-  return loadedModule.exports;
-}
-
-const { ensureHttpBotSigningSecret, getErrorMessage } = loadWizardUtils();
-
-test('generates an HTTP Bot signing secret when signatures are enabled', () => {
-  const config = ensureHttpBotSigningSecret('http_bot', {
-    signature_required: true,
-    inbound_secret: '',
-  });
-
-  assert.match(config.inbound_secret, /^[a-f0-9]{64}$/);
-});
-
-test('preserves existing or intentionally disabled HTTP Bot signing config', () => {
-  const existing = { signature_required: true, inbound_secret: 'keep-me' };
-  const disabled = { signature_required: false, inbound_secret: '' };
-
-  assert.equal(ensureHttpBotSigningSecret('http_bot', existing), existing);
-  assert.equal(ensureHttpBotSigningSecret('http_bot', disabled), disabled);
-});
-
-test('does not add signing config to other adapters', () => {
-  const config = {};
-
-  assert.equal(ensureHttpBotSigningSecret('web_page_bot', config), config);
-});
-
-test('extracts the backend message from structured API errors', () => {
-  assert.equal(
-    getErrorMessage({ code: 400, msg: 'Signing secret is required' }),
-    'Signing secret is required',
-  );
-  assert.equal(getErrorMessage(new Error('Network failed')), 'Network failed');
-});

web/vite.config.ts

@@ -1,39 +1,18 @@
-import { defineConfig, loadEnv } from 'vite';
+import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 import path from 'path';
 
-export default defineConfig(({ mode }) => {
-  const env = loadEnv(mode, process.cwd(), '');
-  const apiProxyTarget = env.VITE_API_PROXY_TARGET || 'http://127.0.0.1:5300';
-
-  return {
-    plugins: [react()],
-    resolve: {
-      alias: {
-        '@': path.resolve(__dirname, './src'),
-      },
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
     },
-    server: {
-      host: '0.0.0.0',
-      port: 3000,
-      proxy: {
-        '/api': {
-          target: apiProxyTarget,
-          changeOrigin: true,
-          ws: true,
-        },
-        '/mcp': {
-          target: apiProxyTarget,
-          changeOrigin: true,
-        },
-        '/bots': {
-          target: apiProxyTarget,
-          changeOrigin: true,
-        },
-      },
-    },
-    build: {
-      outDir: 'dist',
-    },
-  };
+  },
+  server: {
+    port: 3000,
+  },
+  build: {
+    outDir: 'dist',
+  },
 });