feat(api): enable CLI diagnostics on current master

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

@@ -16,7 +16,7 @@ class BoxRouterGroup(group.RouterGroup):
         @self.route(
             '/status',
             methods=['GET'],
-            auth_type=group.AuthType.USER_TOKEN,
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
             permission=Permission.RESOURCE_VIEW,
         )
         async def _(request_context: RequestContext) -> str:
@@ -42,7 +42,7 @@ class BoxRouterGroup(group.RouterGroup):
         @self.route(
             '/sessions',
             methods=['GET'],
-            auth_type=group.AuthType.USER_TOKEN,
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
             permission=Permission.AUDIT_VIEW,
         )
         async def _(request_context: RequestContext) -> str:
@@ -55,7 +55,7 @@ class BoxRouterGroup(group.RouterGroup):
         @self.route(
             '/errors',
             methods=['GET'],
-            auth_type=group.AuthType.USER_TOKEN,
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
             permission=Permission.AUDIT_VIEW,
         )
         async def _(request_context: RequestContext) -> str:

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

@@ -75,7 +75,12 @@ class MonitoringRouterGroup(group.RouterGroup):
 
             return self.success(data=stats)
 
-        @self.route('/messages', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/messages',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_messages(request_context: RequestContext) -> str:
             """Get message logs"""
             # Parse query parameters
@@ -84,8 +89,9 @@ class MonitoringRouterGroup(group.RouterGroup):
             session_ids = quart.request.args.getlist('sessionId')
             start_time_str = quart.request.args.get('startTime')
             end_time_str = quart.request.args.get('endTime')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             # Parse datetime
             start_time = parse_iso_datetime(start_time_str)
@@ -111,7 +117,12 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/llm-calls', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/llm-calls',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_llm_calls(request_context: RequestContext) -> str:
             """Get LLM call records"""
             # Parse query parameters
@@ -119,8 +130,9 @@ class MonitoringRouterGroup(group.RouterGroup):
             pipeline_ids = quart.request.args.getlist('pipelineId')
             start_time_str = quart.request.args.get('startTime')
             end_time_str = quart.request.args.get('endTime')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             # Parse datetime
             start_time = parse_iso_datetime(start_time_str)
@@ -145,7 +157,12 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/tool-calls', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/tool-calls',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_tool_calls(request_context: RequestContext) -> str:
             """Get tool call records"""
             bot_ids = quart.request.args.getlist('botId')
@@ -153,8 +170,9 @@ class MonitoringRouterGroup(group.RouterGroup):
             session_ids = quart.request.args.getlist('sessionId')
             start_time_str = quart.request.args.get('startTime')
             end_time_str = quart.request.args.get('endTime')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             start_time = parse_iso_datetime(start_time_str)
             end_time = parse_iso_datetime(end_time_str)
@@ -179,15 +197,21 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/embedding-calls', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/embedding-calls',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_embedding_calls(request_context: RequestContext) -> str:
             """Get embedding call records"""
             # Parse query parameters
             start_time_str = quart.request.args.get('startTime')
             end_time_str = quart.request.args.get('endTime')
             knowledge_base_id = quart.request.args.get('knowledgeBaseId')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             # Parse datetime
             start_time = parse_iso_datetime(start_time_str)
@@ -211,7 +235,12 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/sessions', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/sessions',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_sessions(request_context: RequestContext) -> str:
             """Get session information"""
             # Parse query parameters
@@ -221,8 +250,9 @@ class MonitoringRouterGroup(group.RouterGroup):
             end_time_str = quart.request.args.get('endTime')
             user_query = quart.request.args.get('userQuery')
             is_active_str = quart.request.args.get('isActive')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             # Parse datetime
             start_time = parse_iso_datetime(start_time_str)
@@ -254,7 +284,12 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/errors', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/errors',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_errors(request_context: RequestContext) -> str:
             """Get error logs"""
             # Parse query parameters
@@ -262,8 +297,9 @@ class MonitoringRouterGroup(group.RouterGroup):
             pipeline_ids = quart.request.args.getlist('pipelineId')
             start_time_str = quart.request.args.get('startTime')
             end_time_str = quart.request.args.get('endTime')
-            limit = int(quart.request.args.get('limit', 100))
-            offset = int(quart.request.args.get('offset', 0))
+            limit, offset = self.ap.monitoring_service.normalize_page_window(
+                quart.request.args.get('limit', 100), quart.request.args.get('offset', 0)
+            )
 
             # Parse datetime
             start_time = parse_iso_datetime(start_time_str)
@@ -404,7 +440,12 @@ class MonitoringRouterGroup(group.RouterGroup):
                 }
             )
 
-        @self.route('/sessions/<session_id>/analysis', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/sessions/<session_id>/analysis',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_session_analysis(session_id: str, request_context: RequestContext) -> str:
             """Get detailed analysis for a specific session"""
             start_time = parse_iso_datetime(quart.request.args.get('startTime'))
@@ -421,13 +462,18 @@ class MonitoringRouterGroup(group.RouterGroup):
             # The frontend will handle the 'found: false' case
             return self.success(data=analysis)
 
-        @self.route('/messages/<message_id>/details', methods=['GET'], permission=Permission.RESOURCE_VIEW)
+        @self.route(
+            '/messages/<message_id>/details',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RESOURCE_VIEW,
+        )
         async def get_message_details(message_id: str, request_context: RequestContext) -> str:
             """Get detailed information for a specific message"""
             details = await self.ap.monitoring_service.get_message_details(request_context, message_id)
 
             if not details.get('found'):
-                return self.error(message=f'Message {message_id} not found', code=404)
+                return self.http_status(404, 'resource_not_found', 'Message not found')
 
             return self.success(data=details)
 

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

@@ -5,6 +5,7 @@ import quart
 from ....authz import Permission, has_permission
 from ....context import RequestContext
 from ....service.secrets import redact_secrets
+from ....service.pipeline_run import run_pipeline
 from ... import group
 from ......pipeline.extension_preferences import (
     normalize_extension_preferences,
@@ -198,3 +199,18 @@ class PipelinesRouterGroup(group.RouterGroup):
             except ValueError as exc:
                 return self.http_status(400, -1, str(exc))
             return self.success()
+
+        @self.route(
+            '/<pipeline_uuid>/run',
+            methods=['POST'],
+            auth_type=group.AuthType.USER_TOKEN_OR_API_KEY,
+            permission=Permission.RUNTIME_OPERATE,
+        )
+        async def run(pipeline_uuid: str, request_context: RequestContext):
+            body = await quart.request.get_json()
+            if not isinstance(body, dict) or set(body) != {'message'}:
+                return self.http_status(400, -1, 'Expected an object containing message')
+            text = body['message']
+            if not isinstance(text, str) or not text.strip() or len(text) > 100_000:
+                return self.http_status(400, -1, 'message must contain 1..100000 characters')
+            return self.success(data=await run_pipeline(self.ap, request_context, pipeline_uuid, text))

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

@@ -13,6 +13,24 @@ from .....workspace.invitation_delivery import InvitationDeliveryService
 
 
 SYSTEM_CAPABILITY_OPERATIONS = (
+    'knowledge_engine.list',
+    'knowledge_engine.creation_schema',
+    'knowledge_engine.retrieval_schema',
+    'knowledge_parser.list',
+    'pipeline.extensions.get',
+    'pipeline.extensions.update',
+    'pipeline.run',
+    'monitoring.messages',
+    'monitoring.llm_calls',
+    'monitoring.tool_calls',
+    'monitoring.embedding_calls',
+    'monitoring.sessions',
+    'monitoring.errors',
+    'monitoring.message_details',
+    'monitoring.session_analysis',
+    'sandbox.status',
+    'sandbox.sessions',
+    'sandbox.errors',
     'bot.list',
     'bot.get',
     'bot.create',

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

@@ -434,58 +434,34 @@ class KnowledgeService:
     # ================= Knowledge Engine Discovery =================
 
     async def list_knowledge_engines(self, context: TenantContext) -> list[dict]:
-        """List all available Knowledge Engines from plugins."""
+        """List engines; unavailable runtimes must not look like empty catalogs."""
         require_workspace_uuid(context)
-        engines = []
-
         if not self.ap.plugin_connector.is_enable_plugin:
-            return engines
+            return []
         await self.ap.plugin_connector.require_workspace_context(context)
-
-        # Get KnowledgeEngine plugins
-        try:
-            knowledge_engines = await self.ap.plugin_connector.list_knowledge_engines()
-            engines.extend(knowledge_engines)
-        except Exception as e:
-            self.ap.logger.warning(f'Failed to list Knowledge Engines from plugins: {e}')
-
-        return engines
+        return await self.ap.plugin_connector.list_knowledge_engines()
 
     async def list_parsers(self, context: TenantContext, mime_type: str | None = None) -> list[dict]:
-        """List available parsers, optionally filtered by MIME type."""
+        """List parsers, optionally filtered by MIME type."""
         require_workspace_uuid(context)
         if not self.ap.plugin_connector.is_enable_plugin:
             return []
         await self.ap.plugin_connector.require_workspace_context(context)
-        try:
-            parsers = await self.ap.plugin_connector.list_parsers()
-            if mime_type:
-                parsers = [p for p in parsers if mime_type in p.get('supported_mime_types', [])]
-            return parsers
-        except Exception as e:
-            self.ap.logger.warning(f'Failed to list parsers: {e}')
-            return []
+        parsers = await self.ap.plugin_connector.list_parsers()
+        return [p for p in parsers if mime_type in p.get('supported_mime_types', [])] if mime_type else parsers
+
+    async def _require_knowledge_engine(self, context: TenantContext, plugin_id: str) -> None:
+        engines = await self.list_knowledge_engines(context)
+        if not any(engine.get('plugin_id') == plugin_id for engine in engines):
+            raise WorkspaceNotFoundError('Knowledge engine not found')
+        await self.ap.plugin_connector.require_workspace_context(context)
 
     async def get_engine_creation_schema(self, context: TenantContext, plugin_id: str) -> dict:
-        """Get creation settings schema for a specific Knowledge Engine."""
-        require_workspace_uuid(context)
-        if not self.ap.plugin_connector.is_enable_plugin:
-            return {}
-        await self.ap.plugin_connector.require_workspace_context(context)
-        try:
-            return await self.ap.plugin_connector.get_rag_creation_schema(plugin_id)
-        except Exception as e:
-            self.ap.logger.warning(f'Failed to get creation schema for {plugin_id}: {e}')
-            return {}
+        """Get an existing engine's creation schema in this Workspace."""
+        await self._require_knowledge_engine(context, plugin_id)
+        return await self.ap.plugin_connector.get_rag_creation_schema(plugin_id)
 
     async def get_engine_retrieval_schema(self, context: TenantContext, plugin_id: str) -> dict:
-        """Get retrieval settings schema for a specific Knowledge Engine."""
-        require_workspace_uuid(context)
-        if not self.ap.plugin_connector.is_enable_plugin:
-            return {}
-        await self.ap.plugin_connector.require_workspace_context(context)
-        try:
-            return await self.ap.plugin_connector.get_rag_retrieval_schema(plugin_id)
-        except Exception as e:
-            self.ap.logger.warning(f'Failed to get retrieval schema for {plugin_id}: {e}')
-            return {}
+        """Get an existing engine's retrieval schema in this Workspace."""
+        await self._require_knowledge_engine(context, plugin_id)
+        return await self.ap.plugin_connector.get_rag_retrieval_schema(plugin_id)

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

@@ -332,6 +332,28 @@ class PipelineService:
 
         return new_uuid
 
+    async def get_pipeline_extensions(self, context: TenantContext, pipeline_uuid: str) -> dict:
+        pipeline = await self.get_pipeline(context, pipeline_uuid)
+        if pipeline is None:
+            raise WorkspaceNotFoundError('Pipeline not found')
+        if self.ap.plugin_connector.is_enable_plugin:
+            await self.ap.plugin_connector.require_workspace_context(context)
+        plugins = await self.ap.plugin_connector.list_plugins(component_kinds=['Command', 'EventListener', 'Tool'])
+        prefs = pipeline.get('extensions_preferences', {})
+        return {
+            'enable_all_plugins': prefs.get('enable_all_plugins', True),
+            'enable_all_mcp_servers': prefs.get('enable_all_mcp_servers', True),
+            'enable_all_skills': prefs.get('enable_all_skills', True),
+            'bound_plugins': prefs.get('plugins', []),
+            'available_plugins': redact_secrets(plugins),
+            'bound_mcp_servers': prefs.get('mcp_servers', []),
+            'available_mcp_servers': await self.ap.mcp_service.get_mcp_servers(context, contain_runtime_info=True),
+            'bound_mcp_resources': prefs.get('mcp_resources', []),
+            'mcp_resource_agent_read_enabled': prefs.get('mcp_resource_agent_read_enabled', True),
+            'bound_skills': prefs.get('skills', []),
+            'available_skills': await self.ap.skill_service.list_skills(context),
+        }
+
     async def update_pipeline_extensions(
         self,
         context: TenantContext,

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

@@ -0,0 +1,68 @@
+"""Single-turn diagnostic execution through the normal Pipeline scheduler."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+
+from langbot_plugin.api.entities.builtin.platform import entities, events, message
+from langbot_plugin.api.entities.builtin.provider.session import LauncherTypes
+
+from ..authz import Permission, require_permission
+from ..context import ExecutionContext, RequestContext
+from ....workspace.errors import WorkspaceNotFoundError
+
+
+async def run_pipeline(ap, context: RequestContext, pipeline_uuid: str, text: str, *, timeout: float = 60) -> dict:
+    """Run in a fresh session; a timed-out request is never submitted again."""
+    require_permission(context, Permission.RUNTIME_OPERATE)
+    if not isinstance(text, str) or not text.strip() or len(text) > 100_000:
+        raise ValueError('message must contain 1..100000 characters')
+    if await ap.pipeline_service.get_pipeline(context, pipeline_uuid) is None:
+        raise WorkspaceNotFoundError('Pipeline not found')
+
+    bot = await ap.platform_mgr.get_websocket_proxy_bot(context)
+    adapter = bot.adapter
+    session_id = str(uuid.uuid4())
+    launcher_id = f'websocket_{pipeline_uuid}:{session_id}'
+    chain = message.MessageChain([message.Plain(text=text)])
+    event = events.FriendMessage(
+        sender=entities.Friend(id=launcher_id, nickname='CLI', remark='CLI'),
+        message_chain=chain,
+        time=time.time(),
+    )
+    execution = ExecutionContext.from_request(context, bot_uuid='websocket-proxy-bot', pipeline_uuid=pipeline_uuid)
+    query = await ap.query_pool.add_query(
+        bot_uuid='websocket-proxy-bot',
+        launcher_type=LauncherTypes.PERSON,
+        launcher_id=launcher_id,
+        sender_id=launcher_id,
+        message_event=event,
+        message_chain=chain,
+        adapter=adapter,
+        pipeline_uuid=pipeline_uuid,
+        variables={'_cli_run_status': 'failed'},
+        execution_context=execution,
+    )
+    completed = asyncio.Event()
+    # add_query returns without yielding after enqueueing, so the scheduler
+    # cannot remove this query before its completion notification is attached.
+    object.__setattr__(query, '_completion_event', completed)
+    data = {'pipeline_uuid': pipeline_uuid, 'session_id': f'person_{launcher_id}', 'query_id': query.query_uuid}
+    try:
+        await asyncio.wait_for(completed.wait(), timeout=timeout)
+    except asyncio.TimeoutError:
+        return {**data, 'status': 'unknown', 'error': 'Execution status unknown; do not automatically retry.'}
+
+    replies = adapter.get_websocket_messages(pipeline_uuid, 'person', session_id)
+    replies = [reply for reply in replies if reply.get('role') == 'assistant']
+    data.update(
+        status=query.variables['_cli_run_status'],
+        replies=replies,
+        reply='\n'.join(reply.get('content', '') for reply in replies),
+        message_id=query.variables.get('_monitoring_message_id'),
+    )
+    if data['status'] != 'completed':
+        data['error'] = 'Pipeline failed or was dropped; inspect the message and call records.'
+    return data