agentpool 2.2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool/mcp_server/conversions.py

@@ -5,16 +5,6 @@ from __future__ import annotations
 import base64
 from typing import TYPE_CHECKING, Any, assert_never
 
-from mcp.types import (
-    AudioContent,
-    BlobResourceContents,
-    EmbeddedResource,
-    ImageContent,
-    PromptMessage,
-    ResourceLink,
-    TextContent,
-    TextResourceContents,
-)
 from pydantic_ai import (
     AudioUrl,
     BinaryContent,
@@ -35,9 +25,14 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from fastmcp import Client
-    from mcp.types import ContentBlock
-    from pydantic_ai import ModelRequestPart, ModelResponsePart
-
+    from mcp.types import (
+        BlobResourceContents,
+        ContentBlock,
+        PromptMessage,
+        SamplingMessage,
+        TextResourceContents,
+    )
+    from pydantic_ai import ModelRequestPart, ModelResponsePart, UserContent
 
 logger = get_logger(__name__)
 
@@ -46,6 +41,13 @@ def to_mcp_messages(
     part: ModelRequestPart | ModelResponsePart,
 ) -> list[PromptMessage]:
     """Convert internal PromptMessage to MCP PromptMessage."""
+    from mcp.types import (
+        AudioContent,
+        ImageContent,
+        PromptMessage,
+        TextContent,
+    )
+
     messages = []
     match part:
         case UserPromptPart(content=str() as c):
@@ -94,6 +96,24 @@ def _url_from_mime_type(uri: str, mime_type: str | None) -> FileUrl:
     return DocumentUrl(url=uri)
 
 
+def sampling_messages_to_user_content(msgs: list[SamplingMessage]) -> list[UserContent]:
+    from mcp import types
+
+    # Convert messages to prompts for the agent
+    prompts: list[UserContent] = []
+    for mcp_msg in msgs:
+        match mcp_msg.content:
+            case types.TextContent(text=text):
+                prompts.append(text)
+            case types.ImageContent(data=data, mimeType=mime_type):
+                binary_data = base64.b64decode(data)
+                prompts.append(BinaryImage(data=binary_data, media_type=mime_type))
+            case types.AudioContent(data=data, mimeType=mime_type):
+                binary_data = base64.b64decode(data)
+                prompts.append(BinaryContent(data=binary_data, media_type=mime_type))
+    return prompts
+
+
 async def from_mcp_content(
     mcp_content: Sequence[ContentBlock | TextResourceContents | BlobResourceContents],
     client: Client[Any] | None = None,
@@ -103,6 +123,16 @@ async def from_mcp_content(
     If a FastMCP client is given, this function will try to resolve the ResourceLinks.
 
     """
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+    )
+
     contents: list[Any] = []
 
     for block in mcp_content:
@@ -151,6 +181,17 @@ async def from_mcp_content(
 
 
 def content_block_as_text(content: ContentBlock) -> str:
+
+    from mcp.types import (
+        AudioContent,
+        BlobResourceContents,
+        EmbeddedResource,
+        ImageContent,
+        ResourceLink,
+        TextContent,
+        TextResourceContents,
+    )
+
     match content:
         case TextContent(text=text):
             return text

agentpool/mcp_server/manager.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 from contextlib import AsyncExitStack
 from typing import TYPE_CHECKING, Any, Self, cast
 
 import anyio
-from pydantic_ai import BinaryContent, BinaryImage, UsageLimits
 
 from agentpool.log import get_logger
 from agentpool.resource_providers import AggregatingResourceProvider, ResourceProvider
@@ -23,7 +21,6 @@ if TYPE_CHECKING:
     from mcp import types
     from mcp.shared.context import RequestContext
     from mcp.types import SamplingMessage
-    from pydantic_ai import UserContent
 
     from agentpool_config.mcp_server import MCPServerConfig
 
@@ -38,6 +35,7 @@ class MCPManager:
         self,
         name: str = "mcp",
         owner: str | None = None,
+        sampling_model: str = "openai:gpt-5-nano",
         servers: Sequence[MCPServerConfig | str] | None = None,
         accessible_roots: list[str] | None = None,
     ) -> None:
@@ -47,6 +45,7 @@ class MCPManager:
         for server in servers or []:
             self.add_server_config(server)
         self.providers: list[MCPResourceProvider] = []
+        self.sampling_model = sampling_model
         self.aggregating_provider = AggregatingResourceProvider(
             providers=cast(list[ResourceProvider], self.providers),
             name=f"{name}_aggregated",
@@ -88,35 +87,22 @@ class MCPManager:
         context: RequestContext[Any, Any, Any],
     ) -> str:
         """Handle MCP sampling by creating a new agent with specified preferences."""
-        from mcp import types
-
         from agentpool.agents import Agent
+        from agentpool.mcp_server.conversions import sampling_messages_to_user_content
 
-        # Convert messages to prompts for the agent
-        prompts: list[UserContent] = []
-        for mcp_msg in messages:
-            match mcp_msg.content:
-                case types.TextContent(text=text):
-                    prompts.append(text)
-                case types.ImageContent(data=data, mimeType=mime_type):
-                    binary_data = base64.b64decode(data)
-                    prompts.append(BinaryImage(data=binary_data, media_type=mime_type))
-                case types.AudioContent(data=data, mimeType=mime_type):
-                    binary_data = base64.b64decode(data)
-                    prompts.append(BinaryContent(data=binary_data, media_type=mime_type))
-
-        # Extract model from preferences
-        model = None
+        prompts = sampling_messages_to_user_content(messages)
+        model = self.sampling_model
         if (prefs := params.modelPreferences) and prefs.hints and prefs.hints[0].name:
-            model = prefs.hints[0].name
+            model = prefs.hints[0].name  # Extract model from preferences
         # Create usage limits from sampling parameters
-        limits = UsageLimits(output_tokens_limit=params.maxTokens, request_limit=1)
+        # limits = UsageLimits(output_tokens_limit=params.maxTokens, request_limit=1)
+        # TODO: Re-add per-turn usage_limits once implemented for all agents
         # TODO: Apply temperature from params.temperature
         sys_prompt = params.systemPrompt or ""
         agent = Agent(name="sampling-agent", model=model, system_prompt=sys_prompt, session=False)
         try:
             async with agent:
-                result = await agent.run(*prompts, store_history=False, usage_limits=limits)
+                result = await agent.run(*prompts, store_history=False)
                 return result.content
 
         except Exception as e:

agentpool/mcp_server/registries/official_registry_client.py

@@ -51,6 +51,9 @@ class RegistryTransport(Schema):
     url: str | None = None
     """URL for HTTP transports."""
 
+    headers: list[dict[str, Any]] = Field(default_factory=list)
+    """Request headers."""
+
 
 class RegistryPackage(Schema):
     """Package information for installing an MCP server."""
@@ -75,6 +78,9 @@ class RegistryPackage(Schema):
     package_arguments: list[dict[str, Any]] = Field(default_factory=list, alias="packageArguments")
     """Package arguments."""
 
+    runtime_arguments: list[dict[str, Any]] = Field(default_factory=list, alias="runtimeArguments")
+    """Runtime arguments."""
+
     runtime_hint: str | None = Field(None, alias="runtimeHint")
     """Runtime hint."""
 
@@ -97,6 +103,9 @@ class RegistryRemote(Schema):
     headers: list[dict[str, Any]] = Field(default_factory=list)
     """Request headers."""
 
+    variables: dict[str, Any] = Field(default_factory=dict)
+    """URL template variables."""
+
 
 class RegistryIcon(Schema):
     """Icon configuration for a server."""
@@ -123,7 +132,7 @@ class RegistryServer(Schema):
     version: str
     """Server version."""
 
-    repository: RegistryRepository
+    repository: RegistryRepository | None = None
     """Repository information."""
 
     packages: list[RegistryPackage] = Field(default_factory=list)

agentpool/mcp_server/tool_bridge.py

@@ -15,12 +15,10 @@ import asyncio
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field, replace
 import inspect
-from typing import TYPE_CHECKING, Any, Literal, Self, get_args, get_origin
+from typing import TYPE_CHECKING, Any, Self, get_args, get_origin
 from uuid import uuid4
 
 import anyio
-from fastmcp import FastMCP
-from fastmcp.tools import Tool as FastMCPTool
 from pydantic import BaseModel, HttpUrl
 
 from agentpool.agents import Agent
@@ -33,12 +31,12 @@ if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Callable
 
     from claude_agent_sdk.types import McpServerConfig
-    from fastmcp import Context
+    from fastmcp import Context, FastMCP
     from fastmcp.tools.tool import ToolResult
     from pydantic_ai import RunContext
     from uvicorn import Server
 
-    from acp.schema.mcp import HttpMcpServer, SseMcpServer
+    from acp.schema.mcp import HttpMcpServer
     from agentpool.agents import AgentContext
     from agentpool.agents.base_agent import BaseAgent
     from agentpool.tools.base import Tool
@@ -154,25 +152,35 @@ def _convert_to_tool_result(result: Any) -> ToolResult:
     """Convert a tool's return value to a FastMCP ToolResult.
 
     Handles different result types appropriately:
-    - ToolResult: Pass through unchanged
+    - FastMCP ToolResult: Pass through unchanged
+    - AgentPool ToolResult: Convert to FastMCP format
     - dict: Use as structured_content (enables programmatic access by clients)
     - Pydantic models: Serialize to dict for structured_content
     - Other types: Pass to ToolResult(content=...) which handles conversion internally
     """
-    from fastmcp.tools.tool import ToolResult
+    from fastmcp.tools.tool import ToolResult as FastMCPToolResult
+
+    from agentpool.tools.base import ToolResult as AgentPoolToolResult
 
-    # Already a ToolResult - pass through
-    if isinstance(result, ToolResult):
+    # Already a FastMCP ToolResult - pass through
+    if isinstance(result, FastMCPToolResult):
         return result
+    # AgentPool ToolResult - convert to FastMCP format
+    if isinstance(result, AgentPoolToolResult):
+        return FastMCPToolResult(
+            content=result.content,
+            structured_content=result.structured_content,
+            meta=result.metadata,
+        )
     # Dict - use as structured_content (FastMCP auto-populates content as JSON)
     if isinstance(result, dict):
-        return ToolResult(structured_content=result)
+        return FastMCPToolResult(structured_content=result)
     # Pydantic model - serialize to dict for structured_content
     if isinstance(result, BaseModel):
-        return ToolResult(structured_content=result.model_dump(mode="json"))
+        return FastMCPToolResult(structured_content=result.model_dump(mode="json"))
     # All other types (str, list, ContentBlock, Image, None, primitives, etc.)
     # ToolResult's internal _convert_to_content handles these correctly
-    return ToolResult(content=result if result is not None else "")
+    return FastMCPToolResult(content=result if result is not None else "")
 
 
 def _extract_tool_call_id(context: Context | None) -> str:
@@ -210,9 +218,6 @@ class BridgeConfig:
     port: int = 0
     """Port to bind to (0 = auto-select available port)."""
 
-    transport: Literal["sse", "streamable-http"] = "sse"
-    """Transport protocol: 'sse' or 'streamable-http'."""
-
     server_name: str = "agentpool-toolmanager"
     """Name for the MCP server."""
 
@@ -271,6 +276,8 @@ class ToolManagerBridge:
 
     async def start(self) -> None:
         """Start the HTTP MCP server in the background."""
+        from fastmcp import FastMCP
+
         self._mcp = FastMCP(name=self.config.server_name)
         await self._register_tools()
         self._subscribe_to_tool_changes()
@@ -333,7 +340,22 @@ class ToolManagerBridge:
             return
 
         # Get current and new tool sets
-        current_names = set(self._mcp._tool_manager._tools.keys())
+        # Support both old and new FastMCP API
+        if hasattr(self._mcp, "_tool_manager"):
+            # Old API (<=2.12.4): direct access to _tool_manager
+            current_names = set(self._mcp._tool_manager._tools.keys())
+        elif hasattr(self._mcp, "_local_provider"):
+            # New API (git): tools stored in _local_provider._components
+            # Keys are prefixed with 'tool:', e.g., 'tool:bash'
+            current_names = {
+                key.removeprefix("tool:")
+                for key in self._mcp._local_provider._components
+                if key.startswith("tool:")
+            }
+        else:
+            # Fallback: use async get_tools() method
+            current_tools = await self._mcp.get_tools()
+            current_names = {t.name for t in current_tools}  # type: ignore[attr-defined]
         new_tools = await self.node.tools.get_tools(state="enabled")
         new_names = {t.name for t in new_tools}
 
@@ -361,19 +383,16 @@ class ToolManagerBridge:
     @property
     def url(self) -> str:
         """Get the server URL."""
-        path = "/sse" if self.config.transport == "sse" else "/mcp"
-        return f"http://{self.config.host}:{self.port}{path}"
+        return f"http://{self.config.host}:{self.port}/mcp"
 
-    def get_mcp_server_config(self) -> HttpMcpServer | SseMcpServer:
+    def get_mcp_server_config(self) -> HttpMcpServer:
         """Get ACP-compatible MCP server configuration.
 
         Returns config suitable for passing to ACP agent's NewSessionRequest.
         """
-        from acp.schema import HttpMcpServer, SseMcpServer
+        from acp.schema import HttpMcpServer
 
         url = HttpUrl(self.url)
-        if self.config.transport == "sse":
-            return SseMcpServer(name=self.config.server_name, url=url, headers=[])
         return HttpMcpServer(name=self.config.server_name, url=url, headers=[])
 
     def get_claude_mcp_server_config(self) -> dict[str, McpServerConfig]:
@@ -416,6 +435,75 @@ class ToolManagerBridge:
         """Register a single tool with the FastMCP server."""
         if not self._mcp:
             return
+        from fastmcp.tools import Tool as FastMCPTool
+
+        class _BridgeTool(FastMCPTool):
+            """Custom FastMCP Tool that wraps a agentpool Tool.
+
+            This allows us to use our own schema and invoke tools with AgentContext.
+            """
+
+            def __init__(self, tool: Tool, bridge: ToolManagerBridge) -> None:
+                # Get input schema from our tool
+                schema = tool.schema["function"]
+                input_schema = schema.get("parameters", {"type": "object", "properties": {}})
+                # Filter out context parameters - they're auto-injected by the bridge
+                context_params = _get_context_param_names(tool.get_callable())
+                run_context_params = _get_run_context_param_names(tool.get_callable())
+                all_context_params = context_params | run_context_params
+                filtered_schema = filter_schema_params(input_schema, all_context_params)
+                desc = tool.description or "No description"
+                super().__init__(name=tool.name, description=desc, parameters=filtered_schema)
+                # Set these AFTER super().__init__() to avoid being overwritten
+                self._tool = tool
+                self._bridge = bridge
+
+            async def run(self, arguments: dict[str, Any]) -> ToolResult:
+                """Execute the wrapped tool with context bridging."""
+                from fastmcp.server.dependencies import get_context
+
+                # Get FastMCP context from context variable (not passed as parameter)
+                try:
+                    mcp_context: Context | None = get_context()
+                except LookupError:
+                    mcp_context = None
+
+                # Try to get Claude's original tool_call_id from request metadata
+                tool_call_id = _extract_tool_call_id(mcp_context)
+                # Get deps from bridge (set by run_stream on the agent)
+                current_deps = self._bridge.current_deps
+                # Create context with tool-specific metadata from node's context.
+                ctx = replace(
+                    self._bridge.node.get_context(data=current_deps),
+                    tool_name=self._tool.name,
+                    tool_call_id=tool_call_id,
+                    tool_input=arguments,
+                )
+                # Invoke with context - copy arguments since invoke_tool_with_context
+                # modifies kwargs in-place to inject context parameters
+                result = await self._bridge.invoke_tool_with_context(
+                    self._tool, ctx, arguments.copy()
+                )
+
+                # Emit metadata event for ClaudeCodeAgent to correlate
+                # (works around Claude SDK stripping MCP _meta field)
+                from agentpool.agents.events import ToolResultMetadataEvent
+                from agentpool.tools.base import ToolResult as AgentPoolToolResult
+
+                if isinstance(result, AgentPoolToolResult) and result.metadata:
+                    logger.info(
+                        "Emitting ToolResultMetadataEvent",
+                        tool_call_id=tool_call_id,
+                        metadata_keys=list(result.metadata.keys()),
+                    )
+                    event = ToolResultMetadataEvent(
+                        tool_call_id=tool_call_id,
+                        metadata=result.metadata,
+                    )
+                    await ctx.events.emit_event(event)
+
+                return _convert_to_tool_result(result)
+
         # Create a custom FastMCP Tool that wraps our tool
         bridge_tool = _BridgeTool(tool=tool, bridge=self)
         self._mcp.add_tool(bridge_tool)
@@ -430,7 +518,7 @@ class ToolManagerBridge:
 
         Handles tools that expect AgentContext, RunContext, or neither.
         """
-        fn = tool.callable
+        fn = tool.get_callable()
 
         # Inject AgentContext parameters
         context_param_names = _get_context_param_names(fn)
@@ -470,7 +558,7 @@ class ToolManagerBridge:
                 port = s.getsockname()[1]
         self._actual_port = port
         # Create the ASGI app
-        app = self._mcp.http_app(transport=self.config.transport)
+        app = self._mcp.http_app(transport="http")
         # Configure uvicorn
         cfg = uvicorn.Config(
             app=app, host=self.config.host, port=port, log_level="warning", ws="websockets-sansio"
@@ -481,58 +569,7 @@ class ToolManagerBridge:
         self._server_task = asyncio.create_task(self._server.serve(), name=name)
         await anyio.sleep(0.1)  # Wait briefly for server to start
         msg = "ToolManagerBridge started"
-        logger.info(msg, url=self.url, transport=self.config.transport)
-
-
-class _BridgeTool(FastMCPTool):
-    """Custom FastMCP Tool that wraps a agentpool Tool.
-
-    This allows us to use our own schema and invoke tools with AgentContext.
-    """
-
-    def __init__(self, tool: Tool, bridge: ToolManagerBridge) -> None:
-        # Get input schema from our tool
-        schema = tool.schema["function"]
-        input_schema = schema.get("parameters", {"type": "object", "properties": {}})
-        # Filter out context parameters - they're auto-injected by the bridge
-        context_params = _get_context_param_names(tool.callable)
-        run_context_params = _get_run_context_param_names(tool.callable)
-        all_context_params = context_params | run_context_params
-        filtered_schema = filter_schema_params(input_schema, all_context_params)
-        desc = tool.description or "No description"
-        super().__init__(name=tool.name, description=desc, parameters=filtered_schema)
-        # Set these AFTER super().__init__() to avoid being overwritten
-        self._tool = tool
-        self._bridge = bridge
-
-    async def run(self, arguments: dict[str, Any]) -> ToolResult:
-        """Execute the wrapped tool with context bridging."""
-        from fastmcp.server.dependencies import get_context
-
-        # Get FastMCP context from context variable (not passed as parameter)
-        try:
-            mcp_context: Context | None = get_context()
-        except LookupError:
-            mcp_context = None
-
-        # Try to get Claude's original tool_call_id from request metadata
-        tool_call_id = _extract_tool_call_id(mcp_context)
-
-        # Get deps from bridge (set by run_stream on the agent)
-        current_deps = self._bridge.current_deps
-
-        # Create context with tool-specific metadata from node's context.
-        ctx = replace(
-            self._bridge.node.get_context(data=current_deps),
-            tool_name=self._tool.name,
-            tool_call_id=tool_call_id,
-            tool_input=arguments,
-        )
-
-        # Invoke with context - copy arguments since invoke_tool_with_context
-        # modifies kwargs in-place to inject context parameters
-        result = await self._bridge.invoke_tool_with_context(self._tool, ctx, arguments.copy())
-        return _convert_to_tool_result(result)
+        logger.info(msg, url=self.url)
 
 
 @asynccontextmanager
@@ -541,7 +578,6 @@ async def create_tool_bridge(
     *,
     host: str = "127.0.0.1",
     port: int = 0,
-    transport: Literal["sse", "streamable-http"] = "sse",
 ) -> AsyncIterator[ToolManagerBridge]:
     """Create and start a ToolManagerBridge as a context manager.
 
@@ -549,12 +585,11 @@ async def create_tool_bridge(
         node: The node whose tools to expose
         host: Host to bind to
         port: Port to bind to (0 = auto-select)
-        transport: Transport protocol ('sse' or 'streamable-http')
 
     Yields:
         Running ToolManagerBridge instance
     """
-    config = BridgeConfig(host=host, port=port, transport=transport)
+    config = BridgeConfig(host=host, port=port)
     bridge = ToolManagerBridge(node=node, config=config)
     async with bridge:
         yield bridge

agentpool/messaging/connection_manager.py

@@ -6,7 +6,8 @@ from collections.abc import Sequence
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, Self
 
-from psygnal import Signal
+from anyenv.signals import Signal
+from psygnal import Signal as Psygnal
 from psygnal.containers import EventedList
 
 from agentpool.log import get_logger
@@ -27,10 +28,10 @@ logger = get_logger(__name__)
 class ConnectionManager:
     """Manages connections for both Agents and Teams."""
 
-    connection_processed = Signal(Talk.ConnectionProcessed)
+    connection_processed = Signal[Talk.ConnectionProcessed]()
 
-    node_connected = Signal(object)  # Node
-    connection_added = Signal(Talk)  # Agent
+    node_connected = Psygnal(object)  # Node
+    connection_added = Psygnal(Talk)  # Agent
 
     def __init__(self, owner: MessageNode[Any, Any]) -> None:
         self.owner = owner
@@ -54,9 +55,9 @@ class ConnectionManager:
         old.connection_processed.disconnect(self._handle_message_flow)
         new.connection_processed.connect(self._handle_message_flow)
 
-    def _handle_message_flow(self, event: Talk.ConnectionProcessed) -> None:
+    async def _handle_message_flow(self, event: Talk.ConnectionProcessed) -> None:
         """Forward message flow to our aggregated signal."""
-        self.connection_processed.emit(event)
+        await self.connection_processed.emit(event)
 
     def set_wait_state(self, target: MessageNode[Any, Any] | AgentName, wait: bool = True) -> None:
         """Set waiting behavior for target."""
@@ -308,10 +309,10 @@ class ConnectionManager:
 if __name__ == "__main__":
     from agentpool.agents import Agent
 
-    agent = Agent("test_agent")
-    agent_2 = Agent("test_agent_2")
-    agent_3 = Agent("test_agent_3")
-    agent_4 = Agent("test_agent_4")
+    agent = Agent("test_agent", model="openai:gpt-5-nano")
+    agent_2 = Agent("test_agent_2", model="openai:gpt-5-nano")
+    agent_3 = Agent("test_agent_3", model="openai:gpt-5-nano")
+    agent_4 = Agent("test_agent_4", model="openai:gpt-5-nano")
     _conn_1 = agent >> agent_2
     _conn_2 = agent >> agent_3
     _conn_3 = agent_2 >> agent_4

agentpool/messaging/event_manager.py

@@ -10,9 +10,9 @@ from functools import wraps
 import inspect
 from typing import TYPE_CHECKING, Any, Self
 
-from evented.configs import EmailConfig, FileWatchConfig, TimeEventConfig, WebhookConfig
+from anyenv.signals import Signal
 from evented.event_data import EventData, FunctionResultEventData
-from psygnal import Signal
+from evented_config import EmailConfig, FileWatchConfig, TimeEventConfig, WebhookConfig
 from pydantic import SecretStr
 
 from agentpool.log import get_logger
@@ -27,8 +27,8 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from evented.base import EventSource
-    from evented.configs import EventConfig
     from evented.timed_watcher import TimeEventSource
+    from evented_config import EventConfig
 
 
 logger = get_logger(__name__)
@@ -40,7 +40,7 @@ type EventCallback = Callable[[EventData], None | Awaitable[None]]
 class EventManager:
     """Manages multiple event sources and their lifecycles."""
 
-    event_processed = Signal(EventData)
+    event_processed = Signal[EventData]()
 
     def __init__(
         self,
@@ -83,7 +83,7 @@ class EventManager:
             except Exception:
                 logger.exception("Error in event callback", name=get_fn_name(callback))
 
-        self.event_processed.emit(event)
+        await self.event_processed.emit(event)
 
     async def add_file_watch(
         self,

agentpool/messaging/message_container.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import itertools
 from typing import TYPE_CHECKING, Any, Literal
 
 from psygnal.containers import EventedList
@@ -145,36 +144,13 @@ class ChatMessageList(EventedList[ChatMessage[Any]]):
             message: Message to build flow DAG for
 
         Returns:
-            Root DAGNode of the graph
+            Root DAGNode of the graph, or None
+
+        Note:
+            forwarded_from has been removed. This method now returns None.
+            Flow tracking can be reconstructed from parent_id chain or pool history.
         """
-        from agentpool.utils.dag import DAGNode
-
-        # Get messages from this conversation
-        conv_messages = [m for m in self if m.conversation_id == message.conversation_id]
-        nodes: dict[str, DAGNode] = {}
-        for msg in conv_messages:  # First create all nodes
-            if msg.forwarded_from:
-                chain = [*msg.forwarded_from, msg.name or "unknown"]
-                for name in chain:
-                    if name not in nodes:
-                        nodes[name] = DAGNode(name)
-
-        # Then set up parent relationships
-        for msg in conv_messages:
-            if msg.forwarded_from:
-                chain = [*msg.forwarded_from, msg.name or "unknown"]
-                # Connect consecutive nodes
-                for parent_name, child_name in itertools.pairwise(chain):
-                    parent = nodes[parent_name]
-                    child = nodes[child_name]
-                    if parent not in child.parents:
-                        child.add_parent(parent)
-
-        # Find root nodes (those without parents)
-        roots = [node for node in nodes.values() if node.is_root]
-        if not roots:
-            return None
-        return roots[0]  # Return first root for now
+        return None
 
     def to_mermaid_graph(
         self,