agent-api-server 2.2.1a2__tar.gz → 2.2.1a3__tar.gz

{agent_api_server-2.2.1a2 → agent_api_server-2.2.1a3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: agent-api-server
-Version: 2.2.1a2
+Version: 2.2.1a3
 Summary: A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot
 Keywords: fastapi,langgraph,agent,api-server
 Requires-Python: >=3.11,<3.14

{agent_api_server-2.2.1a2 → agent_api_server-2.2.1a3}/adapters/openclaw_adapter/openclaw_adapter.py

@@ -3,6 +3,7 @@ import hashlib
 import json
 import logging
 import platform
+import re
 import shlex
 import time
 from pathlib import Path
@@ -317,6 +318,10 @@ class OpenClawAgentAdapter(BaseAgentAdapter):
         self.session_name = self.settings.get("session_name", "main")
         self.query_field = self.settings.get("query_field")
         self.execution_settings = dict(self.settings.get("execution_options") or {})
+        self.run_completion_idle_timeout_seconds = self._resolve_run_completion_idle_timeout_seconds(
+            self.settings,
+            self.execution_settings,
+        )
         self.workspace = self._resolve_workspace(self.settings.get("workspace"))
         self.agent_config = dict(self.settings.get("agent_config") or {})
 
@@ -381,8 +386,11 @@ class OpenClawAgentAdapter(BaseAgentAdapter):
         session_name = self._resolve_session_name(context=context)
         try:
             agent = await self._load_agent(client, context=context)
-            result = await agent.execute(
-                self._resolve_query(inputs),
+            return await self._collect_run_result(
+                agent=agent,
+                query=self._resolve_query(inputs),
+                context=context,
+                session_name=session_name,
                 options=self._build_execution_options(context),
             )
         except Exception as exc:
@@ -390,25 +398,6 @@ class OpenClawAgentAdapter(BaseAgentAdapter):
         finally:
             await client.close()
 
-        if not result.success and result.error_message:
-            raise RuntimeError(result.error_message)
-
-        return ChatMessage(
-            type="ai",
-            content_type=detect_content_type(result.content),
-            content=result.content,
-            tool_calls=[self._normalize_tool_call(tool_call) for tool_call in result.tool_calls],
-            response_metadata={
-                "latency_ms": result.latency_ms,
-                "stop_reason": result.stop_reason,
-                "token_usage": serialize_data(result.token_usage),
-                "completed_at": serialize_data(result.completed_at),
-                "conversation_id": self._resolve_conversation_id(context),
-                "session_name": session_name,
-            },
-            references=[],
-        )
-
     async def stream(self, inputs: dict[str, Any], context: AgentExecutionContext) -> AsyncIterator[str]:
         client = await self._connect_client()
         content_parts: list[str] = []
@@ -693,6 +682,216 @@ class OpenClawAgentAdapter(BaseAgentAdapter):
             options["attachments"] = attachments
         return ExecutionOptions(**options)
 
+    async def _collect_run_result(
+        self,
+        *,
+        agent,
+        query: str,
+        context: AgentExecutionContext,
+        session_name: str,
+        options,
+    ) -> ChatMessage:
+        content_parts: list[str] = []
+        tool_calls: list[dict[str, Any]] = []
+        last_message: ChatMessage | None = None
+        last_tool_message: ChatMessage | None = None
+        event_iterator = agent.execute_stream_typed(query, options=options).__aiter__()
+
+        while True:
+            timeout = self.run_completion_idle_timeout_seconds if last_message is not None else None
+            try:
+                if timeout is None:
+                    event = await anext(event_iterator)
+                else:
+                    event = await asyncio.wait_for(anext(event_iterator), timeout=timeout)
+            except StopAsyncIteration:
+                break
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "OpenClaw run stream idle timeout without DoneEvent; agent=%s session=%s timeout_s=%s last_message_type=%s last_tool_message=%s",
+                    self.agent_id,
+                    session_name,
+                    timeout,
+                    last_message.type if last_message is not None else None,
+                    last_tool_message is not None,
+                )
+                break
+
+            if isinstance(event, ContentEvent):
+                if event.text:
+                    content_parts.append(event.text)
+                    last_message = self._build_ai_message(
+                        content="".join(content_parts),
+                        tool_calls=tool_calls,
+                        context=context,
+                        session_name=session_name,
+                    )
+                continue
+
+            if ThinkingEvent is not None and isinstance(event, ThinkingEvent):
+                continue
+
+            if isinstance(event, ToolCallEvent):
+                tool_calls = [*tool_calls, self._normalize_tool_call({"tool": event.tool, "input": event.input})]
+                last_message = self._build_ai_message(
+                    content="".join(content_parts),
+                    tool_calls=tool_calls,
+                    context=context,
+                    session_name=session_name,
+                )
+                continue
+
+            if isinstance(event, ToolResultEvent):
+                tool_message = self._build_tool_message(
+                    output=event.output,
+                    tool=event.tool,
+                    duration_ms=event.duration_ms,
+                    context=context,
+                    session_name=session_name,
+                )
+                last_message = tool_message
+                if self._is_semantic_tool_message(tool_message):
+                    last_tool_message = tool_message
+                continue
+
+            if isinstance(event, DoneEvent):
+                final_content = event.content or "".join(content_parts)
+                if final_content:
+                    return self._build_ai_message(
+                        content=final_content,
+                        tool_calls=[],
+                        context=context,
+                        session_name=session_name,
+                        extra_metadata={
+                            "token_usage": serialize_data(event.token_usage),
+                            "stop_reason": event.stop_reason,
+                        },
+                    )
+
+                return self._build_terminal_fallback_message(
+                    context=context,
+                    session_name=session_name,
+                    tool_calls=tool_calls,
+                    last_message=last_message,
+                    last_tool_message=last_tool_message,
+                    extra_metadata={"token_usage": serialize_data(event.token_usage), "stop_reason": event.stop_reason},
+                )
+
+            if isinstance(event, ErrorEvent):
+                raise RuntimeError(event.message)
+
+        return self._build_terminal_fallback_message(
+            context=context,
+            session_name=session_name,
+            tool_calls=tool_calls,
+            last_message=last_message,
+            last_tool_message=last_tool_message,
+        )
+
+    def _build_ai_message(
+        self,
+        *,
+        content: str,
+        tool_calls: list[dict[str, Any]],
+        context: AgentExecutionContext,
+        session_name: str,
+        extra_metadata: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        return ChatMessage(
+            type="ai",
+            content_type=detect_content_type(content),
+            content=content,
+            tool_calls=list(tool_calls),
+            response_metadata={
+                "conversation_id": self._resolve_conversation_id(context),
+                "session_name": session_name,
+                **(extra_metadata or {}),
+            },
+            references=[],
+        )
+
+    def _build_terminal_fallback_message(
+        self,
+        *,
+        context: AgentExecutionContext,
+        session_name: str,
+        tool_calls: list[dict[str, Any]],
+        last_message: ChatMessage | None,
+        last_tool_message: ChatMessage | None,
+        extra_metadata: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        if last_tool_message is not None:
+            return last_tool_message.model_copy(
+                update={"response_metadata": {**last_tool_message.response_metadata, **(extra_metadata or {})}}
+            )
+
+        if last_message is not None and last_message.type == "ai":
+            return last_message.model_copy(
+                update={"response_metadata": {**last_message.response_metadata, **(extra_metadata or {})}}
+            )
+
+        return self._build_ai_message(
+            content="",
+            tool_calls=tool_calls,
+            context=context,
+            session_name=session_name,
+            extra_metadata=extra_metadata,
+        )
+
+    @staticmethod
+    def _is_semantic_tool_message(message: ChatMessage) -> bool:
+        content = message.content.strip()
+        if not content:
+            return False
+        if message.content_type != "text":
+            return True
+
+        low_signal_patterns = (
+            r"^Successfully wrote \d+ bytes to .+",
+            r"^Wrote \d+ bytes to .+",
+            r"^File written to .+",
+            r"^Saved to .+",
+        )
+        return not any(re.match(pattern, content) for pattern in low_signal_patterns)
+
+    @staticmethod
+    def _resolve_run_completion_idle_timeout_seconds(
+        settings: dict[str, Any],
+        execution_settings: dict[str, Any],
+    ) -> float | None:
+        for source in (settings, execution_settings):
+            raw_value = source.get("run_completion_idle_timeout_seconds")
+            if raw_value is None:
+                continue
+            timeout = float(raw_value)
+            return timeout if timeout > 0 else None
+        return 5.0
+
+    def _build_tool_message(
+        self,
+        *,
+        output: str,
+        tool: str,
+        duration_ms: Any,
+        context: AgentExecutionContext,
+        session_name: str,
+        extra_metadata: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        return ChatMessage(
+            type="tool",
+            content_type=detect_content_type(output),
+            content=output,
+            tool_calls=[],
+            response_metadata={
+                "duration_ms": duration_ms,
+                "tool": tool,
+                "conversation_id": self._resolve_conversation_id(context),
+                "session_name": session_name,
+                **(extra_metadata or {}),
+            },
+            references=[],
+        )
+
     @staticmethod
     def _build_attachments(items: list[dict[str, Any]]):
         attachments = []

{agent_api_server-2.2.1a2 → agent_api_server-2.2.1a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-api-server"
-version = "2.2.1-alpha2"
+version = "2.2.1-alpha3"
 description = "A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot"
 authors = []
 readme = "README.md"