refactor(box): unify box service lifecycle and local runtime

management

src/langbot/pkg/pipeline/process/handlers/chat.py

@@ -17,12 +17,19 @@ from ....provider import runners
 import langbot_plugin.api.entities.builtin.provider.session as provider_session
 import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
 import langbot_plugin.api.entities.builtin.provider.message as provider_message
+from .. import logging_utils
 
 
 importutil.import_modules_in_pkg(runners)
 
 
 class ChatMessageHandler(handler.MessageHandler):
+    def _format_result_log(
+        self,
+        result: provider_message.Message | provider_message.MessageChunk,
+    ) -> str | None:
+        return logging_utils.format_result_log(result, self.cut_str)
+
     async def handle(
         self,
         query: pipeline_query.Query,
@@ -113,9 +120,11 @@ class ChatMessageHandler(handler.MessageHandler):
                         # This prevents memory overflow from thousands of log entries per conversation
                         # First chunk uses INFO level to confirm connection establishment
                         if chunk_count == 1:
-                            self.ap.logger.info(
-                                f'Conversation({query.query_id}) Streaming started: {self.cut_str(result.readable_str())}'
-                            )
+                            summary = self._format_result_log(result)
+                            if summary is not None:
+                                self.ap.logger.info(f'Conversation({query.query_id}) Streaming started: {summary}')
+                            else:
+                                self.ap.logger.info(f'Conversation({query.query_id}) Streaming started')
                         elif chunk_count % 10 == 0:
                             self.ap.logger.debug(
                                 f'Conversation({query.query_id}) Streaming chunk {chunk_count}: {self.cut_str(result.readable_str())}'
@@ -135,9 +144,9 @@ class ChatMessageHandler(handler.MessageHandler):
                     async for result in runner.run(query):
                         query.resp_messages.append(result)
 
-                        self.ap.logger.info(
-                            f'Conversation({query.query_id}) Response: {self.cut_str(result.readable_str())}'
-                        )
+                        summary = self._format_result_log(result)
+                        if summary is not None:
+                            self.ap.logger.info(f'Conversation({query.query_id}) Response: {summary}')
 
                         if result.content is not None:
                             text_length += len(result.content)

src/langbot/pkg/pipeline/process/logging_utils.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+import typing
+
+import langbot_plugin.api.entities.builtin.provider.message as provider_message
+
+
+def format_result_log(
+    result: provider_message.Message | provider_message.MessageChunk,
+    cut_str: typing.Callable[[str], str],
+) -> str | None:
+    if result.tool_calls:
+        tool_names = [tc.function.name for tc in result.tool_calls if tc.function and tc.function.name]
+        if tool_names:
+            return f'{result.role}: requested tools: {", ".join(tool_names)}'
+        return f'{result.role}: requested tool calls'
+
+    content = result.content
+    if isinstance(content, str):
+        if not content.strip():
+            return None
+
+        if result.role == 'tool':
+            if content.startswith('err:'):
+                return f'tool error: {cut_str(content)}'
+
+            try:
+                payload = json.loads(content)
+            except json.JSONDecodeError:
+                return cut_str(result.readable_str())
+
+            if isinstance(payload, dict):
+                status = payload.get('status', 'unknown')
+                exit_code = payload.get('exit_code')
+                backend = payload.get('backend', '')
+                stdout = str(payload.get('stdout', '')).strip()
+                summary = f'tool result: status={status}'
+                if exit_code is not None:
+                    summary += f' exit_code={exit_code}'
+                if backend:
+                    summary += f' backend={backend}'
+                if stdout:
+                    summary += f' stdout={cut_str(stdout)}'
+                return summary
+
+        return cut_str(result.readable_str())
+
+    if isinstance(content, list) and len(content) == 0:
+        return None
+
+    return cut_str(result.readable_str())