agent-api-server 2.1.9__tar.gz → 2.1.11__tar.gz

{agent_api_server-2.1.9 → agent_api_server-2.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: agent-api-server
-Version: 2.1.9
+Version: 2.1.11
 Summary: A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot
 Author: zijie.zhang@advantech.com.cn
 Requires-Python: >=3.10,<3.13

{agent_api_server-2.1.9 → agent_api_server-2.1.11}/agent_api_server/a2a_bridge/agent_card_builder.py

@@ -222,7 +222,7 @@ class AgentCardBuilder:
             return await self._build_card_for_agent("AgentHub", config)
 
         capabilities = AgentCapabilities(
-            streaming=False,
+            streaming=True,
             push_notifications=False,
         )
 
@@ -304,7 +304,7 @@ class AgentCardBuilder:
         self, agent_name: str, config: Dict[str, Any]
     ) -> AgentCard:
         capabilities = AgentCapabilities(
-            streaming=False,
+            streaming=True,
             push_notifications=False,
         )
 

{agent_api_server-2.1.9 → agent_api_server-2.1.11}/agent_api_server/a2a_bridge/call_a2a_client.py

@@ -1,10 +1,15 @@
 import asyncio
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from uuid import uuid4
+
+import httpx
 from agent_api_server.shared.decode_token import decode_jwt
+from a2a.client.client import ClientConfig
 from a2a.client.client_factory import create_client
 from a2a.types import (
+    AgentCard,
     Message,
     Part,
     Role,
@@ -94,15 +99,56 @@ class AgentHubClient:
             print(result.text)
     """
 
-    def __init__(self, agent_url: str):
+    def __init__(
+        self,
+        agent_url: str = "",
+        timeout: float = 60.0,
+        agent_card: AgentCard | None = None,
+    ):
+        """Initialize the A2A client.
+
+        Args:
+            agent_url: Base URL or full AgentCard URL of the agent.
+                Used when agent_card is not provided.
+            timeout: HTTP timeout for requests.
+            agent_card: Pre-resolved AgentCard. When provided, the client
+                uses it directly without fetching from URL. This is the
+                preferred approach when the caller already has the card.
+        """
         self._agent_url = agent_url
+        self._timeout = timeout
+        self._agent_card = agent_card
         self._client = None
 
     async def _get_client(self):
         if self._client is None:
-            logger.info("Resolving AgentCard from %s", self._agent_url)
-            self._client = await create_client(self._agent_url)
-            logger.info("Client created successfully for %s", self._agent_url)
+            httpx_client = httpx.AsyncClient(
+                timeout=httpx.Timeout(self._timeout, connect=10.0),
+            )
+            client_config = ClientConfig(httpx_client=httpx_client)
+
+            if self._agent_card is not None:
+                # Use the pre-resolved AgentCard directly
+                logger.info(
+                    "Creating client from AgentCard for '%s'",
+                    self._agent_card.name,
+                )
+                self._client = await create_client(
+                    self._agent_card,
+                    client_config=client_config,
+                )
+            else:
+                logger.info("Resolving AgentCard from %s", self._agent_url)
+                self._client = await create_client(
+                    self._agent_url,
+                    client_config=client_config,
+                )
+
+            logger.info(
+                "Client created successfully for %s (timeout=%ss)",
+                self._agent_url or (self._agent_card.name if self._agent_card else "unknown"),
+                self._timeout,
+            )
         return self._client
 
     async def call(
@@ -114,6 +160,7 @@ class AgentHubClient:
         files: list | None = None,
         task_id: str | None = None,
         context_id: str | None = None,
+        on_stream_chunk: Callable[[StreamResponse], None] | None = None,
         **extra_metadata,
     ) -> A2AResult:
         """Send a message to the remote agent and consume the full event stream.
@@ -125,6 +172,8 @@ class AgentHubClient:
             files: Optional file references.
             task_id: Existing task ID for multi-turn continuation.
             context_id: Existing context ID for multi-turn continuation.
+            on_stream_chunk: Optional callback invoked for each streaming event.
+                Enables real-time processing (e.g., logging) of stream chunks.
             **extra_metadata: Additional metadata (e.g., graph_name, app_id).
 
         Returns:
@@ -132,7 +181,11 @@ class AgentHubClient:
         """
         client = await self._get_client()
 
-        graph_name = extra_metadata.get("graph_name", "unknown")
+        # Use agent card name if available, otherwise fall back to graph_name or URL
+        if self._agent_card:
+            graph_name = self._agent_card.name
+        else:
+            graph_name = extra_metadata.get("graph_name", self._agent_url or "unknown")
 
         # Extract user_id from JWT if available
         user_id = None
@@ -178,6 +231,13 @@ class AgentHubClient:
         async for response in client.send_message(request):
             self._process_stream_response(response, result)
 
+            # Invoke streaming callback if provided
+            if on_stream_chunk is not None:
+                try:
+                    on_stream_chunk(response)
+                except Exception as e:
+                    logger.warning("on_stream_chunk callback error: %s", e)
+
             # Stop consuming once we hit a terminal or interrupt state
             if result.task_state in _TERMINAL_STATES or result.task_state in _INTERRUPT_STATES:
                 logger.info(
@@ -198,6 +258,7 @@ class AgentHubClient:
         follow_up_input: str,
         task_id: str,
         context_id: str,
+        on_stream_chunk: Callable[[StreamResponse], None] | None = None,
         **extra_metadata,
     ) -> A2AResult:
         """Send a follow-up message to an existing task in INPUT_REQUIRED state.
@@ -209,6 +270,7 @@ class AgentHubClient:
             follow_up_input: The user's response to the agent's prompt.
             task_id: The task ID from the previous result.
             context_id: The context ID from the previous result.
+            on_stream_chunk: Optional callback invoked for each streaming event.
             **extra_metadata: Additional metadata (e.g., graph_name).
 
         Returns:
@@ -218,6 +280,7 @@ class AgentHubClient:
             raw_question=follow_up_input,
             task_id=task_id,
             context_id=context_id,
+            on_stream_chunk=on_stream_chunk,
             **extra_metadata,
         )
 

{agent_api_server-2.1.9 → agent_api_server-2.1.11}/agent_api_server/a2a_bridge/langgraph_executor.py

@@ -1,7 +1,8 @@
 import asyncio
 import logging
-from typing import Any, Dict
-from langchain_core.messages import AIMessage
+import uuid
+from typing import Any, Dict, AsyncGenerator
+from langchain_core.messages import AIMessage, AIMessageChunk
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.types import Command
 from a2a.server.agent_execution import AgentExecutor, RequestContext
@@ -18,6 +19,71 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
+async def _extract_text_from_stream_event(
+    stream_event: Any,
+) -> AsyncGenerator[str, None]:
+    """Extract readable text content from a LangGraph stream event.
+
+    Unlike handle_stream_event (which wraps output in SSE format for REST),
+    this extracts plain text suitable for A2A artifact transport.
+
+    Handles both 2-tuple (mode, event) and 3-tuple (subgraph_id, mode, event)
+    formats produced by subgraphs=True.
+    """
+    # Unwrap subgraph tuple format: (subgraph_id, stream_mode, event)
+    if isinstance(stream_event, tuple) and len(stream_event) == 3:
+        _, stream_mode, event = stream_event
+        async for chunk in _extract_text_from_stream_event((stream_mode, event)):
+            yield chunk
+        return
+
+    if not (isinstance(stream_event, tuple) and len(stream_event) == 2):
+        return
+
+    stream_mode, event = stream_event
+
+    if stream_mode == "messages":
+        # Token-level streaming: (message_chunk, metadata)
+        if isinstance(event, tuple) and len(event) == 2:
+            message_chunk, metadata = event
+            if isinstance(message_chunk, AIMessageChunk):
+                content = message_chunk.content
+                # Handle list content (multimodal)
+                if isinstance(content, list):
+                    text_parts = []
+                    for item in content:
+                        if isinstance(item, dict) and item.get("type") == "text":
+                            text_parts.append(item.get("text", ""))
+                        elif isinstance(item, str):
+                            text_parts.append(item)
+                    content = "".join(text_parts)
+                if content and isinstance(content, str) and content.strip():
+                    yield content
+
+    elif stream_mode == "updates":
+        # Node-level updates: {node_name: state_updates}
+        if isinstance(event, dict):
+            for node_name, updates in event.items():
+                messages = updates.get("messages", [])
+                for msg in messages:
+                    content = getattr(msg, "content", None)
+                    if isinstance(content, str) and content.strip():
+                        yield f"[{node_name}] {content}\n"
+                    elif isinstance(content, list):
+                        text_parts = []
+                        for item in content:
+                            if isinstance(item, dict) and item.get("type") == "text":
+                                text_parts.append(item.get("text", ""))
+                        text = "".join(text_parts)
+                        if text.strip():
+                            yield f"[{node_name}] {text}\n"
+
+    elif stream_mode == "custom":
+        # Custom events — yield as-is if string
+        if isinstance(event, str) and event.strip():
+            yield event
+
+
 class LangGraphAgentExecutor(AgentExecutor):
     """A2A AgentExecutor that bridges to LangGraph agents.
 
@@ -41,6 +107,11 @@ class LangGraphAgentExecutor(AgentExecutor):
         CANCELED state. The cancel() method actively cancels the running task
         and serves as a fallback for edge cases.
 
+    Streaming:
+        Uses graph.astream() with stream_mode=["updates", "messages", "custom"]
+        to emit incremental artifact chunks. Text content is extracted directly
+        from stream events (no SSE wrapping), suitable for A2A transport.
+
     Graph usage:
         from langgraph.types import interrupt
 
@@ -131,24 +202,13 @@ class LangGraphAgentExecutor(AgentExecutor):
         try:
             await graph_task
         except asyncio.CancelledError:
-            logger.info("Task %s cancelled during execution", task_id)
-            try:
-                await updater.cancel()
-            except RuntimeError:
-                pass
-        except Exception as e:
-            logger.error("Error executing graph '%s': %s", graph_name, e, exc_info=True)
-            await updater.failed(
-                message=Message(
-                    role=Role.ROLE_AGENT,
-                    parts=[Part(text=f"Graph execution failed: {e}")],
-                )
-            )
+            await updater.cancel()
+            logger.info("Task %s -> CANCELED", task_id)
         finally:
             self._running_tasks.pop(task_id, None)
 
-    @staticmethod
     async def _run_graph(
+        self,
         graph: CompiledStateGraph,
         user_input: str,
         metadata: Dict[str, Any],
@@ -156,12 +216,16 @@ class LangGraphAgentExecutor(AgentExecutor):
         updater: TaskUpdater,
         is_continuation: bool,
     ) -> None:
-        """Execute the LangGraph and map its output to A2A terminal states.
+        """Execute the LangGraph with streaming and map output to A2A states.
+
+        Uses graph.astream() for real-time streaming of graph execution events
+        to the A2A client via incremental artifact updates.
 
         Uses LangGraph's native interrupt/resume mechanism for multi-turn:
-          - If graph returns __interrupt__ -> INPUT_REQUIRED
-          - If continuation, resume with Command(resume=user_input)
-          - Otherwise -> COMPLETED with artifact
+          - Checks graph state before streaming for existing interrupts (resume)
+          - Streams events and emits each as an artifact chunk (append=True)
+          - After streaming, checks final state for interrupts -> INPUT_REQUIRED
+          - Otherwise -> COMPLETED
         """
         graph_name = config.get("configurable", {}).get("graph_name", "a2a_agent")
         callbacks_config = build_langfuse_callbacks(run_name=f"A2A_{graph_name}")
@@ -171,7 +235,14 @@ class LangGraphAgentExecutor(AgentExecutor):
         session_id = configurable.get("thread_id", "")
         user_id = configurable.get("user_id", "")
 
-        if is_continuation:
+        # Check for existing interrupts (resume detection) before streaming
+        state_get = await graph.aget_state(config=a2a_config)
+        has_interrupts = any(
+            getattr(task, "interrupts", None)
+            for task in state_get.tasks
+        )
+
+        if has_interrupts or is_continuation:
             graph_input = Command(resume=user_input)
         else:
             graph_input = {}
@@ -182,34 +253,85 @@ class LangGraphAgentExecutor(AgentExecutor):
                 graph_input["agent_name"] = graph_name
             graph_input["user_input"] = user_input
 
-        if callbacks_config and propagate_attributes:
-            with propagate_attributes(
+        # Generate a stable artifact ID for all streaming chunks
+        artifact_id = str(uuid.uuid4())
+        _trace_name = f"A2A_{graph_name}"
+
+        trace_ctx = (
+            propagate_attributes(
                 session_id=session_id,
                 user_id=user_id,
-                trace_name=f"A2A_{graph_name}",
-            ):
-                result = await graph.ainvoke(graph_input, config=a2a_config)
+                trace_name=_trace_name,
+            )
+            if callbacks_config and propagate_attributes
+            else None
+        )
+
+        if trace_ctx:
+            with trace_ctx:
+                await self._stream_graph_and_emit_artifacts(
+                    graph, graph_input, a2a_config, updater, artifact_id,
+                )
         else:
-            result = await graph.ainvoke(graph_input, config=a2a_config)
-
-        if isinstance(result, dict) and "__interrupt__" in result:
-            interrupts = result["__interrupt__"]
-            if interrupts:
-                interrupt_value = interrupts[0].value
-                prompt = str(interrupt_value) if interrupt_value else "Additional input required"
-                await updater.requires_input(
-                    message=Message(
-                        role=Role.ROLE_AGENT,
-                        parts=[Part(text=prompt)],
-                    )
+            await self._stream_graph_and_emit_artifacts(
+                graph, graph_input, a2a_config, updater, artifact_id,
+            )
+
+        # After streaming, check final state for interrupts
+        final_state = await graph.aget_state(config=a2a_config)
+        if final_state.next:
+            # Graph is interrupted — extract interrupt value for the prompt
+            interrupt_values = []
+            for task in final_state.tasks:
+                for interrupt in getattr(task, "interrupts", []):
+                    if hasattr(interrupt, "value") and interrupt.value is not None:
+                        interrupt_values.append(str(interrupt.value))
+            prompt = interrupt_values[0] if interrupt_values else "Additional input required"
+            await updater.requires_input(
+                message=Message(
+                    role=Role.ROLE_AGENT,
+                    parts=[Part(text=prompt)],
                 )
-                logger.info("Task %s -> INPUT_REQUIRED: %s", updater.task_id, prompt)
-                return
+            )
+            logger.info("Task %s -> INPUT_REQUIRED: %s", updater.task_id, prompt)
+        else:
+            await updater.complete()
+            logger.info("Task %s -> COMPLETED", updater.task_id)
 
-        response_text = _extract_response_text(result)
-        await updater.add_artifact(parts=[Part(text=response_text)])
-        await updater.complete()
-        logger.info("Task %s -> COMPLETED", updater.task_id)
+    async def _stream_graph_and_emit_artifacts(
+        self,
+        graph: CompiledStateGraph,
+        graph_input: Any,
+        config: Dict[str, Any],
+        updater: TaskUpdater,
+        artifact_id: str,
+    ) -> None:
+        """Stream graph execution and emit text content as artifact chunks.
+
+        Extracts text directly from stream events (no SSE wrapping).
+        Each chunk is sent as an A2A artifact update with append=True
+        for incremental delivery.
+        """
+        first_chunk = True
+        async for stream_event in graph.astream(
+            graph_input,
+            config=config,
+            stream_mode=["updates", "messages", "custom"],
+            subgraphs=True,
+        ):
+            async for text_chunk in _extract_text_from_stream_event(stream_event):
+                if first_chunk:
+                    await updater.add_artifact(
+                        parts=[Part(text=text_chunk)],
+                        artifact_id=artifact_id,
+                    )
+                    first_chunk = False
+                else:
+                    await updater.add_artifact(
+                        parts=[Part(text=text_chunk)],
+                        artifact_id=artifact_id,
+                        append=True,
+                    )
 
     def _build_config(
         self,
@@ -218,11 +340,20 @@ class LangGraphAgentExecutor(AgentExecutor):
         metadata: Dict[str, Any] = None,
     ) -> Dict[str, Any]:
         metadata = metadata or {}
-        ts_tenant = metadata.get("tenent_id", "")
+        ts_tenant = metadata.get("tenant_id", "")
+
+        # Namespace thread_id by graph_name to isolate checkpoints
+        # across multiple agents sharing the same PostgreSQL checkpointer.
+        # Without this, agents on the same server with the same context_id
+        # would overwrite each other's conversation state.
+        namespaced_thread_id = (
+            f"{graph_name}:{context.context_id}"
+            if graph_name else context.context_id
+        )
 
         configurable = build_configurable(
             graph_name=graph_name,
-            thread_id=context.context_id,
+            thread_id=namespaced_thread_id,
             ts_tenant=ts_tenant,
             ei_token=metadata.get("ei_token", ""),
             files=metadata.get("files"),
@@ -257,15 +388,3 @@ class LangGraphAgentExecutor(AgentExecutor):
             await updater.cancel()
         except RuntimeError:
             pass
-
-
-def _extract_response_text(result: Any) -> str:
-    """Extract the response text from a LangGraph output."""
-    if isinstance(result, dict) and "messages" in result and result["messages"]:
-        last_message = result["messages"][-1]
-        if isinstance(last_message, AIMessage):
-            return last_message.content
-        return str(last_message)
-    if isinstance(result, str):
-        return result
-    return str(result) if result else "No response generated"

{agent_api_server-2.1.9 → agent_api_server-2.1.11}/agent_api_server/acp_bridge/go/agent.go

@@ -39,6 +39,12 @@ type SessionState struct {
 	UpdatedAt string `json:"updated_at,omitempty"`
 }
 
+// pendingToolCall holds buffered tool call info until the tool result is available.
+type pendingToolCall struct {
+	name string
+	args interface{}
+}
+
 // AgentHubACPAgent implements the ACP protocol over stdio, proxying to an HTTP backend.
 type AgentHubACPAgent struct {
 	serviceURL     string
@@ -54,7 +60,7 @@ type AgentHubACPAgent struct {
 	mu               sync.Mutex
 	httpClient       *http.Client
 	sessions         map[string]*SessionState
-	pendingToolCalls map[string]map[string]string // sessionID -> tcID -> tcName
+	pendingToolCalls map[string]map[string]*pendingToolCall // sessionID -> tcID -> info
 	streamedNodes    map[string]map[string]bool   // sessionID -> set of nodes
 }
 
@@ -77,7 +83,7 @@ func NewAgentHubACPAgent(
 		extraInputs:      extraInputs,
 		streamMode:     streamMode,
 		sessions:         make(map[string]*SessionState),
-		pendingToolCalls: make(map[string]map[string]string),
+		pendingToolCalls: make(map[string]map[string]*pendingToolCall),
 		streamedNodes:    make(map[string]map[string]bool),
 		httpClient: &http.Client{
 			Timeout: 300 * time.Second,
@@ -348,24 +354,22 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 			a.mu.Lock()
 			pending := a.pendingToolCalls[sessionID]
 			if pending == nil {
-				pending = make(map[string]string)
+				pending = make(map[string]*pendingToolCall)
 				a.pendingToolCalls[sessionID] = pending
 			}
 			a.mu.Unlock()
 			for _, tc := range toolCalls {
-				tcID, _ := tc["id"].(string)
-				if tcID == "" {
-					tcID = uuid.New().String()
-				}
+				// Always use UUID for tcID to avoid invalid IDs from LangChain
+				tcID := uuid.New().String()
 				tcName, _ := tc["name"].(string)
 				if tcName == "" {
 					tcName = "unknown"
 				}
 				tcArgs := tc["args"]
+				// Buffer tool call info; emit complete tool_call when tools_message arrives
 				a.mu.Lock()
-				pending[tcID] = tcName
+				pending[tcID] = &pendingToolCall{name: tcName, args: tcArgs}
 				a.mu.Unlock()
-				a.sendStartToolCall(sessionID, tcID, tcName, tcArgs, nil, "")
 			}
 		} else if text != "" {
 			a.mu.Lock()
@@ -390,12 +394,13 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 		a.mu.Unlock()
 
 		if len(pending) > 0 {
-			for tcID, tcName := range pending {
+			for tcID, info := range pending {
 				output := text
 				if output == "" {
-					output = tcName + " completed"
+					output = info.name + " completed"
 				}
-				a.sendUpdateToolCall(sessionID, tcID, "completed", output)
+				// Emit single complete tool_call with rawInput + rawOutput
+				a.sendStartToolCall(sessionID, tcID, info.name, info.args, output, "completed")
 			}
 			a.mu.Lock()
 			delete(a.pendingToolCalls, sessionID)
@@ -412,10 +417,8 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 				}
 			}
 			for _, tc := range toolCalls {
-				tcID, _ := tc["id"].(string)
-				if tcID == "" {
-					tcID = uuid.New().String()
-				}
+				// Always use UUID for tcID to avoid invalid IDs from LangChain
+				tcID := uuid.New().String()
 				tcName, _ := tc["name"].(string)
 				if tcName == "" {
 					tcName = "unknown"