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

agentpool/messaging/compaction.py

@@ -22,7 +22,7 @@ Example:
     compacted = await pipeline.apply(messages)
 
     # Or via config (for YAML)
-    config = CompactionPipelineConfig(steps=[
+    config = CompactionConfig(steps=[
         FilterThinkingConfig(),
         TruncateToolOutputsConfig(max_length=1000),
         KeepLastMessagesConfig(count=10),
@@ -50,9 +50,8 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, Annotated, Any, Literal, Self, cast
+from typing import TYPE_CHECKING, Any, Self, cast
 
-from pydantic import BaseModel, Field
 from pydantic_ai import (
     Agent,
     BinaryContent,
@@ -73,6 +72,8 @@ if TYPE_CHECKING:
     from pydantic_ai import ModelRequestPart, ModelResponsePart
     from tokonomics.model_names import ModelId
 
+    from agentpool.messaging.message_history import MessageHistory
+
 # Type aliases
 ModelMessage = ModelRequest | ModelResponse
 MessageSequence = Sequence[ModelMessage]
@@ -629,200 +630,6 @@ class WhenMessageCountExceeds(CompactionStep):
         return list(messages)
 
 
-# =============================================================================
-# Configuration Models - For YAML/JSON configuration
-# =============================================================================
-
-
-class FilterThinkingConfig(BaseModel):
-    """Configuration for FilterThinking step."""
-
-    type: Literal["filter_thinking"] = "filter_thinking"
-
-    def build(self) -> FilterThinking:
-        return FilterThinking()
-
-
-class FilterRetryPromptsConfig(BaseModel):
-    """Configuration for FilterRetryPrompts step."""
-
-    type: Literal["filter_retry_prompts"] = "filter_retry_prompts"
-
-    def build(self) -> FilterRetryPrompts:
-        return FilterRetryPrompts()
-
-
-class FilterBinaryContentConfig(BaseModel):
-    """Configuration for FilterBinaryContent step."""
-
-    type: Literal["filter_binary"] = "filter_binary"
-    keep_references: bool = False
-
-    def build(self) -> FilterBinaryContent:
-        return FilterBinaryContent(keep_references=self.keep_references)
-
-
-class FilterToolCallsConfig(BaseModel):
-    """Configuration for FilterToolCalls step."""
-
-    type: Literal["filter_tools"] = "filter_tools"
-    exclude_tools: list[str] = Field(default_factory=list)
-    include_only: list[str] | None = None
-
-    def build(self) -> FilterToolCalls:
-        return FilterToolCalls(exclude_tools=self.exclude_tools, include_only=self.include_only)
-
-
-class FilterEmptyMessagesConfig(BaseModel):
-    """Configuration for FilterEmptyMessages step."""
-
-    type: Literal["filter_empty"] = "filter_empty"
-
-    def build(self) -> FilterEmptyMessages:
-        return FilterEmptyMessages()
-
-
-class TruncateToolOutputsConfig(BaseModel):
-    """Configuration for TruncateToolOutputs step."""
-
-    type: Literal["truncate_tool_outputs"] = "truncate_tool_outputs"
-    max_length: int = 2000
-    suffix: str = "\n... [truncated]"
-
-    def build(self) -> TruncateToolOutputs:
-        return TruncateToolOutputs(max_length=self.max_length, suffix=self.suffix)
-
-
-class TruncateTextPartsConfig(BaseModel):
-    """Configuration for TruncateTextParts step."""
-
-    type: Literal["truncate_text"] = "truncate_text"
-    max_length: int = 5000
-    suffix: str = "\n... [truncated]"
-
-    def build(self) -> TruncateTextParts:
-        return TruncateTextParts(max_length=self.max_length, suffix=self.suffix)
-
-
-class KeepLastMessagesConfig(BaseModel):
-    """Configuration for KeepLastMessages step."""
-
-    type: Literal["keep_last"] = "keep_last"
-    count: int = 10
-    count_pairs: bool = True
-
-    def build(self) -> KeepLastMessages:
-        return KeepLastMessages(count=self.count, count_pairs=self.count_pairs)
-
-
-class KeepFirstMessagesConfig(BaseModel):
-    """Configuration for KeepFirstMessages step."""
-
-    type: Literal["keep_first"] = "keep_first"
-    count: int = 2
-
-    def build(self) -> KeepFirstMessages:
-        return KeepFirstMessages(count=self.count)
-
-
-class KeepFirstAndLastConfig(BaseModel):
-    """Configuration for KeepFirstAndLast step."""
-
-    type: Literal["keep_first_last"] = "keep_first_last"
-    first_count: int = 2
-    last_count: int = 5
-
-    def build(self) -> KeepFirstAndLast:
-        return KeepFirstAndLast(first_count=self.first_count, last_count=self.last_count)
-
-
-class TokenBudgetConfig(BaseModel):
-    """Configuration for TokenBudget step."""
-
-    type: Literal["token_budget"] = "token_budget"
-    max_tokens: int = 4000
-    model: str = "gpt-4o"
-
-    def build(self) -> TokenBudget:
-        return TokenBudget(max_tokens=self.max_tokens, model=self.model)
-
-
-class SummarizeConfig(BaseModel):
-    """Configuration for Summarize step."""
-
-    type: Literal["summarize"] = "summarize"
-    model: str = "openai:gpt-4o-mini"
-    threshold: int = 15
-    keep_recent: int = 5
-    summary_prompt: str | None = None
-
-    def build(self) -> Summarize:
-        kwargs: dict[str, Any] = {
-            "model": self.model,
-            "threshold": self.threshold,
-            "keep_recent": self.keep_recent,
-        }
-        if self.summary_prompt:
-            kwargs["summary_prompt"] = self.summary_prompt
-        return Summarize(**kwargs)
-
-
-class WhenMessageCountExceedsConfig(BaseModel):
-    """Configuration for WhenMessageCountExceeds wrapper."""
-
-    type: Literal["when_count_exceeds"] = "when_count_exceeds"
-    threshold: int = 20
-    step: "CompactionStepConfig"
-
-    def build(self) -> WhenMessageCountExceeds:
-        return WhenMessageCountExceeds(step=self.step.build(), threshold=self.threshold)
-
-
-# Union of all config types with discriminator
-CompactionStepConfig = Annotated[
-    FilterThinkingConfig
-    | FilterRetryPromptsConfig
-    | FilterBinaryContentConfig
-    | FilterToolCallsConfig
-    | FilterEmptyMessagesConfig
-    | TruncateToolOutputsConfig
-    | TruncateTextPartsConfig
-    | KeepLastMessagesConfig
-    | KeepFirstMessagesConfig
-    | KeepFirstAndLastConfig
-    | TokenBudgetConfig
-    | SummarizeConfig
-    | WhenMessageCountExceedsConfig,
-    Field(discriminator="type"),
-]
-
-# Update forward reference
-WhenMessageCountExceedsConfig.model_rebuild()
-
-
-class CompactionPipelineConfig(BaseModel):
-    """Configuration for a complete compaction pipeline.
-
-    Example YAML:
-        ```yaml
-        compaction:
-          steps:
-            - type: filter_thinking
-            - type: truncate_tool_outputs
-              max_length: 1000
-            - type: keep_last
-              count: 10
-        ```
-    """
-
-    steps: list[CompactionStepConfig] = Field(default_factory=list)
-    """Ordered list of compaction steps to apply."""
-
-    def build(self) -> CompactionPipeline:
-        """Build a CompactionPipeline from this configuration."""
-        return CompactionPipeline(steps=[step.build() for step in self.steps])
-
-
 # =============================================================================
 # Preset Pipelines - Common configurations
 # =============================================================================
@@ -877,6 +684,74 @@ def summarizing_context(model: ModelId | str = "openai:gpt-4o-mini") -> Compacti
 # =============================================================================
 
 
+async def compact_conversation(
+    pipeline: CompactionPipeline,
+    conversation: MessageHistory,
+) -> tuple[int, int]:
+    """Apply a compaction pipeline to a conversation's message history.
+
+    Extracts model messages from ChatMessages, applies the pipeline,
+    and rebuilds the conversation history with compacted messages.
+
+    Args:
+        pipeline: The compaction pipeline to apply
+        conversation: The MessageHistory to compact
+
+    Returns:
+        Tuple of (original_count, compacted_count) of model messages
+    """
+    from agentpool.messaging.messages import ChatMessage
+
+    chat_messages = conversation.get_history()
+    if not chat_messages:
+        return 0, 0
+
+    # Extract ModelRequest/ModelResponse from ChatMessage.messages
+    model_messages: list[ModelMessage] = []
+    for chat_msg in chat_messages:
+        if chat_msg.messages:
+            model_messages.extend(chat_msg.messages)
+
+    if not model_messages:
+        return 0, 0
+
+    original_count = len(model_messages)
+
+    # Apply the compaction pipeline
+    compacted = await pipeline.apply(model_messages)
+
+    # Rebuild ChatMessages from compacted model messages
+    new_chat_messages: list[ChatMessage[Any]] = []
+    current_msgs: list[ModelMessage] = []
+
+    for msg in compacted:
+        current_msgs.append(msg)
+        if isinstance(msg, ModelResponse):
+            new_chat_messages.append(
+                ChatMessage(
+                    content="[compacted]",
+                    role="assistant",
+                    messages=list(current_msgs),
+                )
+            )
+            current_msgs = []
+
+    # Handle any remaining messages (incomplete pair)
+    if current_msgs:
+        new_chat_messages.append(
+            ChatMessage(
+                content="[compacted]",
+                role="user",
+                messages=list(current_msgs),
+            )
+        )
+
+    # Update the conversation history
+    conversation.set_history(new_chat_messages)
+
+    return original_count, len(compacted)
+
+
 def _extract_text_content(msg: ModelMessage) -> str:
     """Extract text content from a message for token counting."""
     parts_text: list[str] = []

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,

agentpool/messaging/message_history.py

@@ -6,10 +6,11 @@ import asyncio
 from collections import deque
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
+import json
 from typing import TYPE_CHECKING, Any, Self, assert_never
 from uuid import UUID, uuid4
 
-from psygnal import Signal
+from anyenv.signals import Signal
 from upathtools import read_path, to_upath
 
 from agentpool.log import get_logger
@@ -24,6 +25,7 @@ if TYPE_CHECKING:
     from datetime import datetime
     from types import TracebackType
 
+    from fsspec.asyn import AsyncFileSystem
     from pydantic_ai import UserContent
     from toprompt import AnyPromptType
     from upathtools import JoinablePathLike
@@ -48,7 +50,7 @@ class MessageHistory:
         session_id: str
         timestamp: datetime = field(default_factory=get_now)
 
-    history_cleared = Signal(HistoryCleared)
+    history_cleared = Signal[HistoryCleared]()
 
     def __init__(
         self,
@@ -94,6 +96,14 @@ class MessageHistory:
         # Note: max_messages and max_tokens will be handled in add_message/get_history
         # to maintain the rolling window during conversation
 
+        # Filesystem for message history
+        from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+        from fsspec.implementations.memory import MemoryFileSystem
+
+        self._memory_fs = MemoryFileSystem()
+        self._fs = AsyncFileSystemWrapper(self._memory_fs)
+        self._fs_initialized = False
+
     @property
     def storage(self) -> StorageManager:
         return self._storage
@@ -150,17 +160,20 @@ class MessageHistory:
         self,
         *,
         max_tokens: int | None = None,
-        include_system: bool = False,
         format_template: str | None = None,
-        num_messages: int | None = None,  # Add this parameter
+        num_messages: int | None = None,
     ) -> str:
         """Format conversation history as a single context message.
 
         Args:
             max_tokens: Optional limit to include only last N tokens
-            include_system: Whether to include system messages
             format_template: Optional custom format (defaults to agent/message pairs)
             num_messages: Optional limit to include only last N messages
+
+        Note:
+            System prompts are stored as metadata (ModelRequest.instructions),
+            not as separate messages with role="system". ChatMessage.role only
+            supports "user" and "assistant".
         """
         template = format_template or "Agent {agent}: {content}\n"
         messages: list[str] = []
@@ -323,14 +336,14 @@ class MessageHistory:
         self.chat_messages.clear()
         self.chat_messages.extend(history)
 
-    def clear(self) -> None:
+    async def clear(self) -> None:
         """Clear conversation history and prompts."""
         from agentpool.messaging import ChatMessageList
 
         self.chat_messages = ChatMessageList()
         self._last_messages = []
         event = self.HistoryCleared(session_id=str(self.id))
-        self.history_cleared.emit(event)
+        await self.history_cleared.emit(event)
 
     @asynccontextmanager
     async def temporary_state(
@@ -477,12 +490,90 @@ class MessageHistory:
         # Use cost_info if available
         return self.chat_messages.get_history_tokens()
 
+    def get_last_message_id(self) -> str | None:
+        """Get the message_id of the last message in history.
+
+        Used for setting parent_id on new messages to build the message tree.
+
+        Returns:
+            The message_id of the last message, or None if history is empty.
+        """
+        if not self.chat_messages:
+            return None
+        return self.chat_messages[-1].message_id
+
+    def _update_filesystem(self) -> None:
+        """Update filesystem with current message history."""
+        # Clear existing files
+        self._memory_fs.store.clear()
+        self._memory_fs.pseudo_dirs.clear()
+
+        # Create directory structure
+        self._memory_fs.makedirs("messages", exist_ok=True)
+        self._memory_fs.makedirs("by_role", exist_ok=True)
+
+        for msg in self.chat_messages:
+            # Format: {timestamp}_{role}_{message_id}
+            timestamp = msg.timestamp.strftime("%Y%m%d_%H%M%S_%f")
+            base_name = f"{timestamp}_{msg.role}_{msg.message_id}"
+
+            # Write message content
+            content_path = f"messages/{base_name}.txt"
+            content = str(msg.content)
+            self._memory_fs.pipe(content_path, content.encode("utf-8"))
+
+            # Write metadata
+            metadata = {
+                "message_id": msg.message_id,
+                "role": msg.role,
+                "timestamp": msg.timestamp.isoformat(),
+                "parent_id": msg.parent_id,
+                "model_name": msg.model_name,
+                "tokens": msg.usage.total_tokens if msg.usage else None,
+                "cost": float(msg.cost_info.total_cost) if msg.cost_info else None,
+            }
+            metadata_path = f"messages/{base_name}.json"
+            self._memory_fs.pipe(metadata_path, json.dumps(metadata, indent=2).encode("utf-8"))
+
+            # Create role-based directory symlinks (by storing paths)
+            role_dir = f"by_role/{msg.role}"
+            self._memory_fs.makedirs(role_dir, exist_ok=True)
+
+        # Write summary
+        summary = {
+            "session_id": self.id,
+            "total_messages": len(self.chat_messages),
+            "total_tokens": self.get_history_tokens(),
+            "total_cost": self.chat_messages.get_total_cost(),
+            "roles": {
+                "user": len([m for m in self.chat_messages if m.role == "user"]),
+                "assistant": len([m for m in self.chat_messages if m.role == "assistant"]),
+            },
+        }
+        self._memory_fs.pipe("summary.json", json.dumps(summary, indent=2).encode("utf-8"))
+
+        self._fs_initialized = True
+
+    def get_fs(self) -> AsyncFileSystem:
+        """Get filesystem view of message history.
+
+        Returns:
+            AsyncFileSystem containing:
+            - messages/{timestamp}_{role}_{message_id}.txt - Message content
+            - messages/{timestamp}_{role}_{message_id}.json - Message metadata
+            - by_role/{role}/ - Messages organized by role
+            - summary.json - Conversation statistics
+        """
+        # Update filesystem on access
+        self._update_filesystem()
+        return self._fs
+
 
 if __name__ == "__main__":
     from agentpool import Agent
 
     async def main() -> None:
-        async with Agent() as agent:
+        async with Agent(model="openai:gpt-5-nano") as agent:
             await agent.conversation.add_context_from_path("E:/mcp_zed.yml")
             print(agent.conversation.get_history())