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

{agent_api_server-2.2.1a2 → agent_api_server-2.2.1a4}/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.1a4
 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.1a4}/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,231 @@ 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_real_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_real_tool_message=%s",
+                    self.agent_id,
+                    session_name,
+                    timeout,
+                    last_message.type if last_message is not None else None,
+                    last_real_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_real_tool_message(tool_message):
+                    last_real_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_real_tool_message=last_real_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_real_tool_message=last_real_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_real_tool_message: ChatMessage | None,
+        extra_metadata: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        if last_real_tool_message is not None:
+            return last_real_tool_message.model_copy(
+                update={"response_metadata": {**last_real_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 _is_real_tool_message(message: ChatMessage) -> bool:
+        content = message.content.strip()
+        if not OpenClawAgentAdapter._is_semantic_tool_message(message):
+            return False
+        if message.content_type != "text":
+            return True
+
+        low_value_status_patterns = (
+            r"^(done|ok|success|completed)\.?$",
+            r"^(analysis|task|job) (done|completed|finished)\.?$",
+            r"^(saved|written) successfully\.?$",
+        )
+        return not any(re.match(pattern, content, re.IGNORECASE) for pattern in low_value_status_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.1a4}/api/thread.py

@@ -57,15 +57,34 @@ def _ensure_thread_ready(state: ThreadState, thread_id: str) -> None:
         )
 
 
+def _thread_agent_conflict(thread_id: str, existing_graph_name: str, requested_graph_name: str) -> HTTPException:
+    return HTTPException(
+        status_code=status.HTTP_409_CONFLICT,
+        detail={
+            "error": "thread_agent_conflict",
+            "message": "Thread is already bound to a different agent",
+            "thread_id": thread_id,
+            "existing_graph_name": existing_graph_name,
+            "requested_graph_name": requested_graph_name,
+        },
+    )
+
+
+def _ensure_thread_matches_graph(
+    state: ThreadState,
+    *,
+    thread_id: str,
+    requested_graph_name: str | None = None,
+) -> None:
+    if requested_graph_name and state.graph_name != requested_graph_name:
+        raise _thread_agent_conflict(thread_id, state.graph_name, requested_graph_name)
+
+
 async def _resolve_thread_for_execution(thread_id: str, request: Request) -> ThreadState:
     graph_name = request.headers.get("X-Agent-Name", "")
     state = await _get_or_create_thread(thread_id, graph_name)
     _ensure_thread_ready(state, thread_id)
-
-    if graph_name:
-        logger.info("Graph name overridden by header: %s", graph_name)
-        state.graph_name = graph_name
-
+    _ensure_thread_matches_graph(state, thread_id=thread_id, requested_graph_name=graph_name or None)
     return state
 
 
@@ -114,6 +133,7 @@ async def _get_or_create_thread(thread_id: str, graph_name: Optional[str] = "")
     storage = AsyncRedisThreadStorage.get_worker_instance()
     thread_data = await storage.get_thread(thread_id)
     if thread_data:
+        _ensure_thread_matches_graph(thread_data, thread_id=thread_id, requested_graph_name=graph_name or None)
         return thread_data
 
     if not graph_name:
@@ -248,10 +268,12 @@ async def create_thread(graph_name: str, thread_id: Optional[str] = None) -> Thr
     if thread_id:
         try:
             state = await _get_existing_thread_or_404(thread_id)
+            _ensure_thread_matches_graph(state, thread_id=thread_id, requested_graph_name=graph_name)
             logger.info("%s already exists, returning existing thread", thread_id)
             return _thread_info(state)
-        except HTTPException:
-            pass
+        except HTTPException as exc:
+            if exc.status_code != status.HTTP_404_NOT_FOUND:
+                raise
 
     storage = None
     thread_state = None

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

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

{agent_api_server-2.2.1a2 → agent_api_server-2.2.1a4}/sdk/client.py

@@ -1,4 +1,5 @@
 from typing import Any, AsyncIterator, Iterator
+from uuid import uuid4
 
 from core import AgentDefinition, AgentExecutionContext, AgentFramework, AgentManager, get_agent_manager
 from core import BaseAgentAdapter
@@ -177,6 +178,10 @@ class AgentSDK:
             await self.manager.get_definition(resolved_agent_name)
         return {}
 
+    @staticmethod
+    def _resolve_thread_id(thread_id: str | None) -> str:
+        return thread_id or f"sdk-{uuid4().hex}"
+
     @staticmethod
     def _build_context(
         agent_name: str,
@@ -201,7 +206,7 @@ class AgentSDK:
         self,
         agent_name: str,
         query: str | dict[str, Any],
-        thread_id: str,
+        thread_id: str | None,
         ts_tenant: str | None,
         ei_token: str | None,
         attachments: list[dict[str, Any]] | None,
@@ -209,9 +214,10 @@ class AgentSDK:
         use_system_llm: bool | str | None,
     ) -> tuple[dict[str, Any], AgentExecutionContext]:
         inputs, normalized_attachments = normalize_agent_query(query, attachments)
+        resolved_thread_id = self._resolve_thread_id(thread_id)
         context = self._build_context(
             agent_name=agent_name,
-            thread_id=thread_id,
+            thread_id=resolved_thread_id,
             ts_tenant=ts_tenant,
             ei_token=ei_token,
             attachments=normalized_attachments,
@@ -225,7 +231,7 @@ class AgentSDK:
         agent_name: str | dict[str, Any] | None = None,
         query: str | dict[str, Any] | None = None,
         *,
-        thread_id: str = "sdk",
+        thread_id: str | None = None,
         ts_tenant: str | None = None,
         ei_token: str | None = None,
         attachments: list[dict[str, Any]] | None = None,
@@ -251,7 +257,7 @@ class AgentSDK:
         agent_name: str | dict[str, Any] | None = None,
         query: str | dict[str, Any] | None = None,
         *,
-        thread_id: str = "sdk",
+        thread_id: str | None = None,
         ts_tenant: str | None = None,
         ei_token: str | None = None,
         attachments: list[dict[str, Any]] | None = None,
@@ -277,7 +283,7 @@ class AgentSDK:
         agent_name: str | dict[str, Any] | None = None,
         query: str | dict[str, Any] | None = None,
         *,
-        thread_id: str = "sdk",
+        thread_id: str | None = None,
         ts_tenant: str | None = None,
         ei_token: str | None = None,
         attachments: list[dict[str, Any]] | None = None,
@@ -304,7 +310,7 @@ class AgentSDK:
         agent_name: str | dict[str, Any] | None = None,
         query: str | dict[str, Any] | None = None,
         *,
-        thread_id: str = "sdk",
+        thread_id: str | None = None,
         ts_tenant: str | None = None,
         ei_token: str | None = None,
         attachments: list[dict[str, Any]] | None = None,