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

agentpool_toolsets/builtin/subagent_tools.py

@@ -5,18 +5,11 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic_ai import (
-    FunctionToolCallEvent,
-    FunctionToolResultEvent,
     ModelRetry,
     PartDeltaEvent,
-    PartStartEvent,
-    RetryPromptPart,
-    TextPart,
     TextPartDelta,
-    ThinkingPart,
     ThinkingPartDelta,
     ToolCallPartDelta,
-    ToolReturnPart,
 )
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
@@ -129,58 +122,60 @@ async def batch_stream_deltas(  # noqa: PLR0915
         yield _make_batched_event()
 
 
-async def _stream_agent_with_progress(
+async def _stream_subagent(
     ctx: AgentContext,
+    source_name: str,
+    source_type: Literal["agent", "team_parallel", "team_sequential"],
     stream: AsyncIterator[RichAgentStreamEvent[Any]],
     *,
     batch_deltas: bool = False,
+    depth: int = 1,
 ) -> str:
-    """Stream an agent's execution and emit progress events.
+    """Stream a subagent's execution, emitting SubAgentEvents into parent stream.
 
     Args:
         ctx: Agent context for emitting events
+        source_name: Name of the subagent/team
+        source_type: Whether source is "agent" or "team"
         stream: Async iterator of stream events from agent.run_stream()
         batch_deltas: If True, batch consecutive text/thinking deltas for fewer UI updates
+        depth: Nesting depth for nested delegation
 
     Returns:
-        Aggregated content from the stream
+        Final text content from the stream
     """
+    from agentpool.agents.events import StreamCompleteEvent, SubAgentEvent
+
     if batch_deltas:
         stream = batch_stream_deltas(stream)
 
-    aggregated: list[str] = []
+    final_content: str = ""
     async for event in stream:
-        match event:
-            case (
-                PartStartEvent(part=TextPart(content=delta))
-                | PartDeltaEvent(delta=TextPartDelta(content_delta=delta))
-            ):
-                aggregated.append(delta)
-                await ctx.events.tool_call_progress("".join(aggregated))
-            case (
-                PartStartEvent(part=ThinkingPart(content=delta))
-                | PartDeltaEvent(delta=ThinkingPartDelta(content_delta=delta))
-            ):
-                if delta:
-                    aggregated.append(f"💭 {delta}")
-                    await ctx.events.tool_call_progress("".join(aggregated))
-            case FunctionToolCallEvent(part=part):
-                aggregated.append(f"\n🔧 Using tool: {part.tool_name}\n")
-                await ctx.events.tool_call_progress("".join(aggregated))
-            case FunctionToolResultEvent(
-                result=ToolReturnPart(content=content, tool_name=tool_name),
-            ):
-                aggregated.append(f"✅ {tool_name}: {content}\n")
-                await ctx.events.tool_call_progress("".join(aggregated))
+        # Handle nested SubAgentEvents - increment depth
+        if isinstance(event, SubAgentEvent):
+            nested_event = SubAgentEvent(
+                source_name=event.source_name,
+                source_type=event.source_type,
+                event=event.event,
+                depth=event.depth + depth,
+            )
+            await ctx.events.emit_event(nested_event)
+        else:
+            # Wrap the event in SubAgentEvent
+            subagent_event = SubAgentEvent(
+                source_name=source_name,
+                source_type=source_type,
+                event=event,
+                depth=depth,
+            )
+            await ctx.events.emit_event(subagent_event)
 
-            case FunctionToolResultEvent(result=RetryPromptPart(tool_name=tool_name) as result):
-                error_message = result.model_response()
-                aggregated.append(f"❌ {tool_name or 'unknown'}: {error_message}\n")
-                await ctx.events.tool_call_progress("".join(aggregated))
-            case _:
-                pass
+            # Extract final content from StreamCompleteEvent
+            if isinstance(event, StreamCompleteEvent):
+                content = event.message.content
+                final_content = str(content) if content else ""
 
-    return "".join(aggregated).strip()
+    return final_content
 
 
 class SubagentTools(StaticResourceProvider):
@@ -269,6 +264,10 @@ class SubagentTools(StaticResourceProvider):
         Returns:
             The result of the delegated task
         """
+        from agentpool import Team, TeamRun
+        from agentpool.agents.base_agent import BaseAgent
+        from agentpool.common_types import SupportsRunStream
+
         if not ctx.pool:
             msg = "Agent needs to be in a pool to delegate tasks"
             raise ToolError(msg)
@@ -278,15 +277,26 @@ class SubagentTools(StaticResourceProvider):
                 f"Available nodes: {', '.join(ctx.pool.nodes.keys())}"
             )
             raise ModelRetry(msg)
+        # Determine source type and get node
+        node = ctx.pool.nodes[agent_or_team_name]
+        match node:
+            case Team():
+                source_type: Literal["team_parallel", "team_sequential", "agent"] = "team_parallel"
+            case TeamRun():
+                source_type = "team_sequential"
+            case BaseAgent():
+                source_type = "agent"
+        if not isinstance(node, SupportsRunStream):
+            msg = f"Node {agent_or_team_name} does not support streaming"
+            raise ToolError(msg)
 
-        # For teams, use simple run() - no streaming support yet
-        if agent_or_team_name in ctx.pool.teams:
-            result = await ctx.pool.teams[agent_or_team_name].run(prompt)
-            return result.format(style="detailed", show_costs=True)
-        # For agents (regular or ACP), stream with progress events
-        agent = ctx.pool.all_agents[agent_or_team_name]
-        return await _stream_agent_with_progress(
-            ctx, agent.run_stream(prompt), batch_deltas=self._batch_stream_deltas
+        # Stream with SubAgentEvent wrapping
+        return await _stream_subagent(
+            ctx,
+            source_name=agent_or_team_name,
+            source_type=source_type,
+            stream=node.run_stream(prompt),
+            batch_deltas=self._batch_stream_deltas,
         )
 
     async def ask_agent(  # noqa: D417
@@ -315,9 +325,12 @@ class SubagentTools(StaticResourceProvider):
 
         agent = ctx.pool.all_agents[agent_name]
         try:
-            stream = agent.run_stream(message)
-            return await _stream_agent_with_progress(
-                ctx, stream, batch_deltas=self._batch_stream_deltas
+            return await _stream_subagent(
+                ctx,
+                source_name=agent_name,
+                source_type="agent",
+                stream=agent.run_stream(message),
+                batch_deltas=self._batch_stream_deltas,
             )
         except Exception as e:
             msg = f"Failed to ask agent {agent_name}: {e}"

agentpool_toolsets/builtin/workers.py

@@ -11,6 +11,8 @@ from agentpool.tools.exceptions import ToolError
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool.tools.base import Tool
     from agentpool_config.workers import WorkerConfig
 
@@ -35,7 +37,7 @@ class WorkersTools(ResourceProvider):
         super().__init__(name=name)
         self.workers = workers
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools for all configured workers."""
         return [self._create_worker_tool(i) for i in self.workers]
 
@@ -78,7 +80,7 @@ class WorkersTools(ResourceProvider):
                 old_history = worker.conversation.get_history()
                 worker.conversation.set_history(ctx.agent.conversation.get_history())
             elif reset_history_on_run:
-                worker.conversation.clear()
+                await worker.conversation.clear()
 
             try:
                 result = await worker.run(prompt)

agentpool_toolsets/composio_toolset.py

@@ -10,7 +10,7 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Sequence
 
     from agentpool.tools.base import Tool
 
@@ -52,7 +52,7 @@ class ComposioTools(ResourceProvider):
         handle_tool_call.__name__ = tool_slug
         return handle_tool_call
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools from composio."""
         # Return cached tools if available
         if self._tools is not None:

agentpool_toolsets/entry_points.py

@@ -12,6 +12,8 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool.tools.base import Tool
 
 
@@ -27,7 +29,7 @@ class EntryPointTools(ResourceProvider):
         self._tools: list[Tool] | None = None
         self.registry = EntryPointRegistry[Callable[..., Any]]("agentpool")
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools from entry points."""
         # Return cached tools if available
         if self._tools is not None:

agentpool_toolsets/fsspec_toolset/grep.py

@@ -328,19 +328,27 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
     matches: list[dict[str, Any]] = []
     total_bytes = 0
     was_truncated = False
+    match_count = 0  # Track actual matches (not context lines)
 
     for line in stdout.splitlines():
         if not line.strip():
             continue
         try:
             data = anyenv.load_json(line, return_type=dict)
-            if data.get("type") == "match":
+            entry_type = data.get("type")
+
+            if entry_type in ("match", "context"):
                 match_data = data.get("data", {})
                 path = match_data.get("path", {}).get("text", "")
                 line_num = match_data.get("line_number", 0)
                 content = match_data.get("lines", {}).get("text", "").rstrip("\n")
 
-                match_entry = {"path": path, "line": line_num, "content": content}
+                match_entry = {
+                    "path": path,
+                    "line": line_num,
+                    "content": content,
+                    "is_match": entry_type == "match",
+                }
                 entry_size = len(path) + len(str(line_num)) + len(content) + 10
 
                 if total_bytes + entry_size > max_output_bytes:
@@ -349,6 +357,9 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
 
                 matches.append(match_entry)
                 total_bytes += entry_size
+
+                if entry_type == "match":
+                    match_count += 1
         except anyenv.JsonLoadError:
             continue
 
@@ -363,11 +374,13 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
         # Truncate long lines for readability
         if len(content) > 100:  # noqa: PLR2004
             content = content[:97] + "..."
-        table_lines.append(f"| {m['path']} | {m['line']} | {content} |")
+        # Mark match lines with indicator if there are context lines
+        prefix = "→ " if m.get("is_match") and match_count < len(matches) else ""
+        table_lines.append(f"| {m['path']} | {m['line']} | {prefix}{content} |")
 
     return {
         "matches": "\n".join(table_lines),
-        "match_count": len(matches),
+        "match_count": match_count,
         "was_truncated": was_truncated,
     }
 
@@ -406,10 +419,17 @@ def _parse_gnu_grep_output(stdout: str, max_output_bytes: int) -> dict[str, Any]
 
     table_lines = ["| File | Line | Content |", "|------|------|---------|"]
     for m in matches:
+        # Handle separator lines
+        if m.get("is_separator"):
+            table_lines.append("| | | |")
+            continue
+
         content = m["content"].replace("|", "\\|")
         if len(content) > 100:  # noqa: PLR2004
             content = content[:97] + "..."
-        table_lines.append(f"| {m['path']} | {m['line']} | {content} |")
+        # Mark match lines with indicator if there are context lines
+        prefix = "→ " if m.get("is_match") else ""
+        table_lines.append(f"| {m['path']} | {m['line']} | {prefix}{content} |")
 
     return {
         "matches": "\n".join(table_lines),

agentpool_toolsets/fsspec_toolset/helpers.py

@@ -550,8 +550,9 @@ def truncate_lines(
     Returns:
         Tuple of (truncated_lines, was_truncated)
     """
-    # Apply offset
-    start_idx = max(0, offset)
+    # Apply offset (supports negative indexing like Python lists)
+    start_idx = max(0, len(lines) + offset) if offset < 0 else min(offset, len(lines))
+
     if start_idx >= len(lines):
         return [], False