aip-agents-binary 0.5.25b9__py3-none-any.whl → 0.6.0__py3-none-any.whl

aip_agents/agent/langgraph_react_agent.py

@@ -18,14 +18,14 @@ from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import asdict, dataclass
 from functools import reduce
 from textwrap import dedent
-from typing import TYPE_CHECKING, Annotated, Any
+from typing import TYPE_CHECKING, Annotated, Any, cast
 
-from deprecated import deprecated
+from deprecated import deprecated  # type: ignore[import-untyped]
 
 if TYPE_CHECKING:
     from aip_agents.guardrails.manager import GuardrailManager
-from gllm_core.event import EventEmitter
-from gllm_core.schema import Chunk
+from gllm_core.event import EventEmitter  # type: ignore[import-untyped]
+from gllm_core.schema import Chunk  # type: ignore[import-untyped]
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
@@ -212,6 +212,12 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             **kwargs,
         )
 
+        if self.model is None and self.lm_invoker is None:
+            logger.warning(
+                "Agent '%s': Model and LM invoker are both unset. Calls that require a model will fail.",
+                self.name,
+            )
+
         # Handle tool output management
         self.tool_output_manager = tool_output_manager
         self._pii_handlers_by_thread: dict[str, ToolPIIHandler] = {}
@@ -256,7 +262,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
         # Auto-configure TodoListMiddleware if planning enabled
         if planning:
-            middleware_list.append(TodoListMiddleware())
+            middleware_list.append(cast(AgentMiddleware, TodoListMiddleware()))
 
         # Auto-configure GuardrailMiddleware if guardrail provided
         if guardrail:
@@ -732,7 +738,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         pending_artifacts: list[dict[str, Any]] = state.get("artifacts") or []
         reference_updates: list[Chunk] = []
         tool_map = {tool.name: tool for tool in self.resolved_tools}
-        pii_mapping = {}
+        pii_mapping: dict[str, str] = {}
 
         aggregated_metadata_delta: dict[str, Any] = {}
         total_tools_token_usage: list[UsageMetadata] = []
@@ -756,7 +762,8 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
                 ),
             )
 
-        tasks = [asyncio.create_task(run_tool(tc)) for tc in last_message.tool_calls]
+        normalized_tool_calls = [self._normalize_tool_call(tc) for tc in last_message.tool_calls]
+        tasks = [asyncio.create_task(run_tool(tc)) for tc in normalized_tool_calls]
 
         for coro in asyncio.as_completed(tasks):
             tool_result = await coro
@@ -779,6 +786,31 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             pii_mapping,
         )
 
+    def _normalize_tool_call(self, tool_call: Any) -> dict[str, Any]:
+        """Normalize tool call inputs into a dict with required keys."""
+        if isinstance(tool_call, dict):
+            normalized = dict(tool_call)
+        elif hasattr(tool_call, "model_dump"):
+            normalized = tool_call.model_dump()
+        elif hasattr(tool_call, "dict"):
+            normalized = tool_call.dict()
+        elif hasattr(tool_call, "name") and hasattr(tool_call, "args"):
+            normalized = {
+                "id": getattr(tool_call, "id", None),
+                "name": getattr(tool_call, "name", None),
+                "args": getattr(tool_call, "args", None),
+            }
+        else:
+            raise TypeError("Tool call must be a dict-like object or ToolCall instance.")
+
+        if not isinstance(normalized, dict):
+            raise TypeError("Tool call normalization did not produce a dict.")
+
+        if "name" not in normalized or "args" not in normalized:
+            raise TypeError("Tool call must include 'name' and 'args' fields.")
+
+        return normalized
+
     def _accumulate_tool_result(  # noqa: PLR0913
         self,
         tool_result: Any,
@@ -787,7 +819,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         aggregated_metadata_delta: dict[str, Any],
         reference_updates: list[Chunk],
         total_tools_token_usage: list[UsageMetadata],
-        pii_mapping: dict[str, str] | None,
+        pii_mapping: dict[str, str],
     ) -> None:  # noqa: PLR0913
         """Accumulate results from a single tool call.
 
@@ -1233,13 +1265,16 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
             # Create enhanced tool configuration with output management
             tool_config = self._create_enhanced_tool_config(config, state, tool_call["name"], tool_call_id)
+            if not isinstance(tool_config, dict):
+                raise TypeError("Tool configuration must be a dictionary.")
+            tool_config_runnable = tool_config
 
             arun_streaming_method = getattr(tool, TOOL_RUN_STREAMING_METHOD, None)
 
             if arun_streaming_method and callable(arun_streaming_method):
                 tool_output = await self._execute_tool_with_streaming(tool, tool_call, tool_config)
             else:
-                tool_output = await tool.ainvoke(resolved_args, tool_config)
+                tool_output = await tool.ainvoke(resolved_args, tool_config_runnable)
 
             references = extract_references_from_tool(tool, tool_output)
 
@@ -1513,7 +1548,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         tool_call: dict[str, Any],
         execution_time: float,
         pending_artifacts: list[dict[str, Any]],
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Process tool output into messages, artifacts, and metadata.
 
         Args:
@@ -1541,7 +1576,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
     def _handle_command_output(
         self, tool_output: Command, tool_call: dict[str, Any], execution_time: float, metadata_delta: dict[str, Any]
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle Command type tool outputs.
 
         Args:
@@ -1570,7 +1605,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
     def _handle_string_output(
         self, tool_output: str, tool_call: dict[str, Any], execution_time: float
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle string type tool outputs.
 
         Args:
@@ -1596,7 +1631,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         execution_time: float,
         pending_artifacts: list[dict[str, Any]],
         metadata_delta: dict[str, Any],
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle legacy dict and other tool outputs.
 
         Args:
@@ -1694,8 +1729,11 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             self._emit_default_tool_call_event(writer, tool_name, tool_call_id, tool_args)
 
             streaming_kwargs = self._build_streaming_kwargs(tool_args, tool_config)
+            arun_streaming_method = getattr(tool, TOOL_RUN_STREAMING_METHOD, None)
+            if not callable(arun_streaming_method):
+                raise RuntimeError(f"Tool '{tool_name}' does not implement streaming.")
 
-            async for chunk in tool.arun_streaming(**streaming_kwargs):
+            async for chunk in arun_streaming_method(**streaming_kwargs):
                 final_output, saw_tool_result = self._handle_streaming_chunk(
                     chunk=chunk,
                     writer=writer,
@@ -2125,6 +2163,9 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
         effective_event_emitter = state.get("event_emitter") or self.event_emitter
 
+        if self.lm_invoker is None:
+            raise RuntimeError("LM invoker is required for this execution path.")
+
         if self.resolved_tools:
             self.lm_invoker.set_tools(self.resolved_tools)
 
@@ -2183,6 +2224,9 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         ):
             langchain_prompt = [SystemMessage(content=enhanced_instruction)] + list(current_messages)
 
+        if self.model is None:
+            raise RuntimeError("Model is required for this execution path.")
+
         model_with_tools = self.model.bind_tools(self.resolved_tools) if self.resolved_tools else self.model
 
         ai_message = await model_with_tools.ainvoke(langchain_prompt, config)

aip_agents/examples/compare_streaming_client.py

@@ -8,10 +8,10 @@ This script demonstrates:
 
 Prerequisites:
     Start the server first:
-        uv run python -m aip_agents.examples.compare_streaming_server
+        poetry run python -m aip_agents.examples.compare_streaming_server
 
 Then run this client:
-    uv run python -m aip_agents.examples.compare_streaming_client
+    poetry run python -m aip_agents.examples.compare_streaming_client
 
 Authors:
     AI Agent Platform Team

aip_agents/examples/compare_streaming_server.py

@@ -6,7 +6,7 @@ This server provides an agent with:
 
 To run this server:
     cd libs/aip_agents
-    uv run python -m aip_agents.examples.compare_streaming_server
+    poetry run python -m aip_agents.examples.compare_streaming_server
 
 It will listen on http://localhost:18999 by default.
 

aip_agents/examples/hello_world_tool_output_client.py

@@ -39,6 +39,15 @@ async def main():
             print(chunk["content"], end="", flush=True)
         if chunk.get("metadata"):
             print(f"\nMetadata: {chunk['metadata']}", end="\n\n", flush=True)
+        tool_info = chunk.get("metadata", {}).get("tool_info") if isinstance(chunk.get("metadata"), dict) else None
+        if isinstance(tool_info, dict):
+            for tool_call in tool_info.get("tool_calls", []):
+                if tool_call.get("name") == "data_visualizer":
+                    data_source = tool_call.get("args", {}).get("data_source")
+                    if not (isinstance(data_source, str) and data_source.startswith("$tool_output.")):
+                        raise RuntimeError(
+                            "Tool output sharing failed: expected data_source to reference $tool_output.<call_id>."
+                        )
     print("\n")
 
 

aip_agents/examples/todolist_planning_a2a_langchain_client.py

@@ -1,10 +1,10 @@
 """A2A client for the planning LangGraphReactAgent.
 
 Run the planning server first:
-    uv run python -m aip_agents.examples.todolist_planning_a2a_langgraph_server
+    poetry run python -m aip_agents.examples.todolist_planning_a2a_langgraph_server
 
 Then run this client:
-    uv run python -m aip_agents.examples.todolist_planning_a2a_langchain_client
+    poetry run python -m aip_agents.examples.todolist_planning_a2a_langchain_client
 
 You should see streaming output, including when write_todos_tool is called.
 """

aip_agents/examples/todolist_planning_a2a_langgraph_server.py

@@ -1,7 +1,7 @@
 """A2A server exposing a LangGraphReactAgent with planning (TodoListMiddleware).
 
 Run:
-    uv run python -m aip_agents.examples.todolist_planning_a2a_langgraph_server \
+    poetry run python -m aip_agents.examples.todolist_planning_a2a_langgraph_server \
         --host localhost --port 8002
 
 Then connect with the matching A2A client to observe write_todos_tool calls.

aip_agents/guardrails/engines/base.py

@@ -39,7 +39,7 @@ class GuardrailEngine(Protocol):
         Returns:
             GuardrailResult indicating if content is safe
         """
-        ...
+        ...  # pragma: no cover
 
     @abstractmethod
     async def check_output(self, content: str) -> GuardrailResult:
@@ -51,12 +51,12 @@ class GuardrailEngine(Protocol):
         Returns:
             GuardrailResult indicating if content is safe
         """
-        ...
+        ...  # pragma: no cover
 
     @abstractmethod
     def model_dump(self) -> dict:
         """Serialize engine configuration into a JSON-compatible dictionary."""
-        ...
+        ...  # pragma: no cover
 
 
 class BaseGuardrailEngine(ABC):
@@ -77,14 +77,14 @@ class BaseGuardrailEngine(ABC):
     @abstractmethod
     async def check_input(self, content: str) -> GuardrailResult:
         """Check user input content for safety violations."""
-        ...
+        ...  # pragma: no cover
 
     @abstractmethod
     async def check_output(self, content: str) -> GuardrailResult:
         """Check AI output content for safety violations."""
-        ...
+        ...  # pragma: no cover
 
     @abstractmethod
     def model_dump(self) -> dict:
         """Serialize engine configuration into a JSON-compatible dictionary."""
-        ...
+        ...  # pragma: no cover

aip_agents/mcp/client/connection_manager.py

@@ -60,6 +60,9 @@ class MCPConnectionManager:
     async def start(self) -> tuple[Any, Any]:
         """Start connection in background task.
 
+        For HTTP/SSE transports, establishes connection directly to avoid anyio context issues.
+        For stdio transport, uses background task to manage subprocess lifecycle.
+
         Returns:
             tuple[Any, Any]: Tuple of (read_stream, write_stream) for ClientSession
 
@@ -67,6 +70,17 @@ class MCPConnectionManager:
             Exception: If connection establishment fails
         """
         logger.debug(f"Starting connection manager for {self.server_name}")
+
+        # Determine transport type first
+        self.transport_type = self._get_transport_type()
+
+        # For HTTP/SSE: connect directly (no background task needed)
+        # This avoids anyio.BrokenResourceError when streams cross task boundaries
+        if self.transport_type in (TransportType.HTTP, TransportType.SSE):
+            await self._establish_connection()
+            return self._connection
+
+        # For stdio: use background task to manage subprocess
         self._task = asyncio.create_task(self._connection_task())
         await self._ready_event.wait()
 
@@ -78,6 +92,20 @@ class MCPConnectionManager:
     async def stop(self) -> None:
         """Stop connection gracefully."""
         logger.debug(f"Stopping connection manager for {self.server_name}")
+
+        # For HTTP/SSE (no background task), just close transport
+        if self.transport_type in (TransportType.HTTP, TransportType.SSE):
+            if self._transport:
+                try:
+                    close_result = self._transport.close()
+                    if inspect.isawaitable(close_result):
+                        await close_result
+                except Exception as exc:
+                    logger.warning(f"Failed to close transport cleanly for {self.server_name}: {exc}")
+            self._connection = None
+            return
+
+        # For stdio (with background task), wait for task to finish
         if self._task and not self._task.done():
             self._stop_event.set()
             try:
@@ -94,6 +122,11 @@ class MCPConnectionManager:
         Returns:
             bool: True if connected, False otherwise
         """
+        # For HTTP/SSE (no background task), just check if connection exists
+        if self.transport_type in (TransportType.HTTP, TransportType.SSE):
+            return self._connection is not None
+
+        # For stdio (with background task), check task status too
         return (
             self._connection is not None
             and self._task is not None
@@ -144,7 +177,9 @@ class MCPConnectionManager:
         Raises:
             ConnectionError: If all connection attempts fail
         """
-        self.transport_type = self._get_transport_type()
+        # transport_type may already be set by start() for HTTP/SSE
+        if not self.transport_type:
+            self.transport_type = self._get_transport_type()
         details = f"URL: {self.config.get('url', 'N/A')}, Command: {self.config.get('command', 'N/A')}"
         logger.info(f"Establishing connection to {self.server_name} via {self.transport_type} ({details})")
 

aip_agents/mcp/client/connection_manager.pyi

@@ -31,6 +31,9 @@ class MCPConnectionManager:
     async def start(self) -> tuple[Any, Any]:
         """Start connection in background task.
 
+        For HTTP/SSE transports, establishes connection directly to avoid anyio context issues.
+        For stdio transport, uses background task to manage subprocess lifecycle.
+
         Returns:
             tuple[Any, Any]: Tuple of (read_stream, write_stream) for ClientSession