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

agentpool/storage/manager.py

@@ -3,37 +3,73 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import dataclass
+import os
 from typing import TYPE_CHECKING, Any, Self
 
 from anyenv import method_spawner
+from anyenv.signals import Signal
+from pydantic import BaseModel
 from pydantic_ai import Agent
 
 from agentpool.log import get_logger
 from agentpool.messaging import ChatMessage
 from agentpool.storage.serialization import serialize_messages
 from agentpool.utils.tasks import TaskManager
+from agentpool_config.session import SessionQuery
 from agentpool_config.storage import (
+    ClaudeStorageConfig,
     FileStorageConfig,
     MemoryStorageConfig,
+    OpenCodeStorageConfig,
     SQLStorageConfig,
-    TextLogConfig,
+    ZedStorageConfig,
 )
 
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
     from datetime import datetime
     from types import TracebackType
 
     from agentpool.common_types import JsonValue
     from agentpool.sessions.models import ProjectData
-    from agentpool_config.session import SessionQuery
     from agentpool_config.storage import BaseStorageProviderConfig, StorageConfig
     from agentpool_storage.base import StorageProvider
 
 logger = get_logger(__name__)
 
 
+class ConversationMetadata(BaseModel):
+    """Generated metadata for a conversation."""
+
+    title: str
+    """Short descriptive title (3-7 words)."""
+
+    emoji: str
+    """Single emoji representing the topic."""
+
+    icon: str
+    """Iconify icon name (e.g., 'mdi:code-braces')."""
+
+
+@dataclass(frozen=True, slots=True)
+class TitleGeneratedEvent:
+    """Event emitted when a conversation title is generated.
+
+    Attributes:
+        conversation_id: ID of the conversation
+        title: Generated title text
+        emoji: Generated emoji representing the topic
+        icon: Generated iconify icon name
+    """
+
+    conversation_id: str
+    title: str
+    emoji: str
+    icon: str
+
+
 class StorageManager:
     """Manages multiple storage providers.
 
@@ -42,8 +78,19 @@ class StorageManager:
     - Message distribution to providers
     - History loading from capable providers
     - Global logging filters
+
+    Signals:
+    - title_generated: Emitted when a conversation title is generated.
+      Subscribers receive TitleGeneratedEvent with conversation_id, title, emoji, icon.
+
+    Example:
+        manager.title_generated.connect(my_handler)
+        # Handler will be called with TitleGeneratedEvent when titles are generated
     """
 
+    # Signal emitted when a conversation title is generated
+    title_generated: Signal[TitleGeneratedEvent] = Signal()
+
     def __init__(self, config: StorageConfig) -> None:
         """Initialize storage manager.
 
@@ -53,6 +100,7 @@ class StorageManager:
         self.config = config
         self.task_manager = TaskManager()
         self.providers = [self._create_provider(cfg) for cfg in self.config.effective_providers]
+        self._conversation_logged: set[str] = set()  # Track logged conversations for idempotency
 
     async def __aenter__(self) -> Self:
         """Initialize all providers."""
@@ -124,15 +172,22 @@ class StorageManager:
                 from agentpool_storage.file_provider import FileProvider
 
                 return FileProvider(provider_config)
-            case TextLogConfig():
-                from agentpool_storage.text_log_provider import TextLogProvider
-
-                return TextLogProvider(provider_config)
-
             case MemoryStorageConfig():
                 from agentpool_storage.memory_provider import MemoryStorageProvider
 
                 return MemoryStorageProvider(provider_config)
+            case ClaudeStorageConfig():
+                from agentpool_storage.claude_provider import ClaudeStorageProvider
+
+                return ClaudeStorageProvider(provider_config)
+            case OpenCodeStorageConfig():
+                from agentpool_storage.opencode_provider import OpenCodeStorageProvider
+
+                return OpenCodeStorageProvider(provider_config)
+            case ZedStorageConfig():
+                from agentpool_storage.zed_provider import ZedStorageProvider
+
+                return ZedStorageProvider(provider_config)
             case _:
                 msg = f"Unknown provider type: {provider_config}"
                 raise ValueError(msg)
@@ -154,11 +209,7 @@ class StorageManager:
         # Function to find capable provider by name
         def find_provider(name: str) -> StorageProvider | None:
             for p in self.providers:
-                if (
-                    not getattr(p, "write_only", False)
-                    and p.can_load_history
-                    and p.__class__.__name__.lower() == name.lower()
-                ):
+                if p.can_load_history and p.__class__.__name__.lower() == name.lower():
                     return p
             return None
 
@@ -175,7 +226,7 @@ class StorageManager:
 
         # Find first capable provider
         for provider in self.providers:
-            if not getattr(provider, "write_only", False) and provider.can_load_history:
+            if provider.can_load_history:
                 return provider
 
         msg = "No capable provider found for loading history"
@@ -214,7 +265,6 @@ class StorageManager:
                     cost_info=message.cost_info,
                     model=message.model_name,
                     response_time=message.response_time,
-                    forwarded_from=message.forwarded_from,
                     provider_name=message.provider_name,
                     provider_response_id=message.provider_response_id,
                     messages=serialize_messages(message.messages),
@@ -228,16 +278,68 @@ class StorageManager:
         conversation_id: str,
         node_name: str,
         start_time: datetime | None = None,
+        initial_prompt: str | None = None,
+        on_title_generated: Callable[[str], None] | None = None,
     ) -> None:
-        """Log conversation to all providers."""
+        """Log conversation to all providers (idempotent).
+
+        If conversation was already logged, skips provider calls but still
+        triggers title generation if initial_prompt is provided.
+
+        Args:
+            conversation_id: Unique conversation identifier
+            node_name: Name of the node/agent
+            start_time: Optional start time
+            initial_prompt: Optional initial prompt to trigger title generation
+            on_title_generated: Optional callback invoked when title is generated
+        """
         if not self.config.log_conversations:
             return
 
-        for provider in self.providers:
-            await provider.log_conversation(
+        # Check if already logged (idempotent behavior)
+        if conversation_id not in self._conversation_logged:
+            # Mark as logged before calling providers
+            self._conversation_logged.add(conversation_id)
+
+            # Log to all providers
+            for provider in self.providers:
+                await provider.log_conversation(
+                    conversation_id=conversation_id,
+                    node_name=node_name,
+                    start_time=start_time,
+                )
+
+        # Handle title generation based on prompt length
+        # Skip during tests to avoid external API calls
+        if not initial_prompt or os.environ.get("PYTEST_CURRENT_TEST"):
+            return
+        prompt_length = len(initial_prompt)
+        logger.info(
+            "log_conversation title decision",
+            conversation_id=conversation_id,
+            prompt_length=prompt_length,
+            has_model=bool(self.config.title_generation_model),
+        )
+
+        # For short prompts, use them directly as title (like Claude Code)
+        if prompt_length < 60:  # noqa: PLR2004
+            logger.info(
+                "Using short prompt directly as title",
+                conversation_id=conversation_id,
+                title=initial_prompt,
+            )
+            await self.update_conversation_title(conversation_id, initial_prompt)
+        # For longer prompts, generate semantic title if model configured
+        elif self.config.title_generation_model:
+            logger.info(
+                "Creating title generation task for long prompt",
                 conversation_id=conversation_id,
-                node_name=node_name,
-                start_time=start_time,
+            )
+            self.task_manager.create_task(
+                self._generate_title_from_prompt(
+                    conversation_id, initial_prompt, on_title_generated
+                ),
+                name=f"title_gen_{conversation_id[:8]}",
             )
 
     @method_spawner
@@ -365,6 +467,140 @@ class StorageManager:
         provider = self.get_history_provider()
         return await provider.get_conversation_title(conversation_id)
 
+    async def get_conversation_titles(
+        self,
+        conversation_ids: list[str],
+    ) -> dict[str, str | None]:
+        """Get titles for multiple conversations.
+
+        Args:
+            conversation_ids: List of conversation IDs
+
+        Returns:
+            Dict mapping conversation_id to title (or None if not set)
+        """
+        if not conversation_ids:
+            return {}
+
+        provider = self.get_history_provider()
+        titles: dict[str, str | None] = {}
+        for conv_id in conversation_ids:
+            try:
+                titles[conv_id] = await provider.get_conversation_title(conv_id)
+            except Exception:  # noqa: BLE001
+                titles[conv_id] = None
+        return titles
+
+    async def get_message_counts(
+        self,
+        conversation_ids: list[str],
+    ) -> dict[str, int]:
+        """Get message counts for multiple conversations.
+
+        Args:
+            conversation_ids: List of conversation IDs
+
+        Returns:
+            Dict mapping conversation_id to message count
+        """
+        if not conversation_ids:
+            return {}
+
+        counts: dict[str, int] = {}
+        for conv_id in conversation_ids:
+            try:
+                query = SessionQuery(name=conv_id)
+                messages = await self.filter_messages(query)
+                counts[conv_id] = len(messages) if messages else 0
+            except Exception:  # noqa: BLE001
+                counts[conv_id] = 0
+        return counts
+
+    @method_spawner
+    async def get_conversation_messages(
+        self,
+        conversation_id: str,
+        *,
+        include_ancestors: bool = False,
+    ) -> list[ChatMessage[str]]:
+        """Get all messages for a conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            include_ancestors: If True, also include messages from ancestor
+                conversations by following the parent_id chain. Useful for
+                forked conversations.
+
+        Returns:
+            List of messages ordered by timestamp.
+        """
+        provider = self.get_history_provider()
+        return await provider.get_conversation_messages(
+            conversation_id, include_ancestors=include_ancestors
+        )
+
+    @method_spawner
+    async def get_message(self, message_id: str) -> ChatMessage[str] | None:
+        """Get a single message by ID.
+
+        Args:
+            message_id: ID of the message
+
+        Returns:
+            The message if found, None otherwise.
+        """
+        provider = self.get_history_provider()
+        return await provider.get_message(message_id)
+
+    @method_spawner
+    async def get_message_ancestry(self, message_id: str) -> list[ChatMessage[str]]:
+        """Get the ancestry chain of a message.
+
+        Traverses the parent_id chain to build full history leading to this message.
+
+        Args:
+            message_id: ID of the message
+
+        Returns:
+            List of messages from oldest ancestor to the specified message.
+        """
+        provider = self.get_history_provider()
+        return await provider.get_message_ancestry(message_id)
+
+    @method_spawner
+    async def fork_conversation(
+        self,
+        *,
+        source_conversation_id: str,
+        new_conversation_id: str,
+        fork_from_message_id: str | None = None,
+        new_agent_name: str | None = None,
+    ) -> str | None:
+        """Fork a conversation at a specific point.
+
+        Creates a new conversation that branches from the source. New messages
+        in the forked conversation should use the returned fork_point_id as
+        their parent_id to maintain the history chain.
+
+        Args:
+            source_conversation_id: ID of the conversation to fork from
+            new_conversation_id: ID for the new forked conversation
+            fork_from_message_id: Message ID to fork from. If None, forks from
+                the last message.
+            new_agent_name: Agent name for the new conversation.
+
+        Returns:
+            The message_id of the fork point (use as parent_id for new messages),
+            or None if the source conversation is empty.
+        """
+        provider = self.get_history_provider()
+        return await provider.fork_conversation(
+            source_conversation_id=source_conversation_id,
+            new_conversation_id=new_conversation_id,
+            fork_from_message_id=fork_from_message_id,
+            new_agent_name=new_agent_name,
+        )
+
     @method_spawner
     async def delete_conversation_messages(
         self,
@@ -434,7 +670,6 @@ class StorageManager:
                     model_name=message.model_name,
                     cost_info=message.cost_info,
                     response_time=message.response_time,
-                    forwarded_from=message.forwarded_from,
                     timestamp=message.timestamp,
                     provider_name=message.provider_name,
                     provider_response_id=message.provider_response_id,
@@ -446,6 +681,105 @@ class StorageManager:
 
         return deleted, added
 
+    async def _generate_title_core(
+        self,
+        conversation_id: str,
+        prompt_text: str,
+    ) -> ConversationMetadata | None:
+        """Core title generation logic using LLM with structured output.
+
+        Args:
+            conversation_id: ID of the conversation to title
+            prompt_text: Formatted prompt text to send to the LLM
+
+        Returns:
+            ConversationMetadata with title, emoji, and icon, or None if generation fails.
+        """
+        logger.info("_generate_title_core called", conversation_id=conversation_id)
+        if not self.config.title_generation_model:
+            logger.info("No title_generation_model configured, skipping")
+            return None
+
+        try:
+            from llmling_models.models.helpers import infer_model
+
+            model = infer_model(self.config.title_generation_model)
+            agent: Agent[None, ConversationMetadata] = Agent(
+                model=model,
+                instructions=self.config.title_generation_prompt,
+                output_type=ConversationMetadata,
+            )
+            logger.debug("Title generation prompt", prompt_text=prompt_text)
+            result = await agent.run(prompt_text)
+            metadata = result.output
+
+            # Store the title
+            await self.update_conversation_title(conversation_id, metadata.title)
+            logger.debug(
+                "Generated conversation metadata",
+                conversation_id=conversation_id,
+                title=metadata.title,
+                emoji=metadata.emoji,
+                icon=metadata.icon,
+            )
+
+            # Emit signal for subscribers (e.g., OpenCode UI updates)
+            event = TitleGeneratedEvent(
+                conversation_id=conversation_id,
+                title=metadata.title,
+                emoji=metadata.emoji,
+                icon=metadata.icon,
+            )
+            logger.info(
+                "Emitting title_generated signal",
+                conversation_id=conversation_id,
+                title=metadata.title,
+            )
+            await self.title_generated.emit(event)
+        except Exception:
+            logger.exception("Failed to generate session title", conversation_id=conversation_id)
+            return None
+        else:
+            return metadata
+
+    async def _generate_title_from_prompt(
+        self,
+        conversation_id: str,
+        prompt: str,
+        on_title_generated: Callable[[str], None] | None = None,
+    ) -> str | None:
+        """Generate title from initial prompt (internal, fire-and-forget).
+
+        Called automatically by log_conversation when initial_prompt is provided.
+
+        Args:
+            conversation_id: ID of the conversation to title
+            prompt: The initial user prompt
+            on_title_generated: Optional callback invoked with the generated title
+
+        Returns:
+            The generated title, or None if generation fails/disabled.
+        """
+        # Check if title already exists
+        existing = await self.get_conversation_title(conversation_id)
+        if existing:
+            if on_title_generated:
+                on_title_generated(existing)
+            return existing
+
+        # Generate using core logic
+        metadata = await self._generate_title_core(
+            conversation_id,
+            f"user: {prompt[:500]}",
+        )
+
+        if metadata:
+            title = metadata.title
+            if on_title_generated:
+                on_title_generated(title)
+            return title
+        return None
+
     async def generate_conversation_title(
         self,
         conversation_id: str,
@@ -463,43 +797,18 @@ class StorageManager:
         Returns:
             The generated title, or None if title generation is disabled.
         """
-        if not self.config.title_generation_model:
-            return None
-
         # Check if title already exists
         existing = await self.get_conversation_title(conversation_id)
         if existing:
             return existing
 
         # Format messages for the prompt
-        formatted = "\n".join(
-            f"{msg.role}: {msg.content[:500]}"
-            for msg in messages[:4]  # Limit context
-        )
+        formatted = "\n".join(f"{i.role}: {i.content[:500]}" for i in messages[:4])
 
-        try:
-            agent: Agent[None, str] = Agent(
-                model=self.config.title_generation_model,
-                instructions=self.config.title_generation_prompt,
-            )
-            result = await agent.run(formatted)
-            title = result.output.strip().strip("\"'")  # Remove quotes if present
+        # Generate using core logic
+        metadata = await self._generate_title_core(conversation_id, formatted)
 
-            # Store the title
-            await self.update_conversation_title(conversation_id, title)
-            logger.debug(
-                "Generated conversation title",
-                conversation_id=conversation_id,
-                title=title,
-            )
-        except Exception:
-            logger.exception(
-                "Failed to generate conversation title",
-                conversation_id=conversation_id,
-            )
-            return None
-        else:
-            return title
+        return metadata.title if metadata else None
 
     # Project methods
 
@@ -512,10 +821,8 @@ class StorageManager:
         Raises:
             RuntimeError: If no capable provider found.
         """
-        for provider in self.providers:
-            # TextLogProvider doesn't support projects, others do
-            if hasattr(provider, "save_project") and not getattr(provider, "write_only", False):
-                return provider
+        if self.providers:
+            return self.providers[0]
         msg = "No provider found that supports project storage"
         raise RuntimeError(msg)
 

agentpool/talk/registry.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal
 
-from psygnal import Signal
+from anyenv.signals import Signal
 
 from agentpool.log import get_logger
 from agentpool.talk.talk import Talk
@@ -64,7 +64,7 @@ class ConnectionRegistry(BaseRegistry[str, Talk]):
     connections get registered.
     """
 
-    message_flow = Signal(Talk.ConnectionProcessed)
+    message_flow = Signal[Talk.ConnectionProcessed]()
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Initialize registry and connect event handlers."""
@@ -90,9 +90,9 @@ class ConnectionRegistry(BaseRegistry[str, Talk]):
         new_talk.connection_processed.connect(self._handle_message_flow)
         logger.debug("Reconnected signal for talk", name=name)
 
-    def _handle_message_flow(self, event: Talk.ConnectionProcessed) -> None:
+    async def _handle_message_flow(self, event: Talk.ConnectionProcessed) -> None:
         """Forward message flow to global stream."""
-        self.message_flow.emit(event)
+        await self.message_flow.emit(event)
 
     @property
     def _error_class(self) -> type[ConnectionRegistryError]:

agentpool/talk/talk.py

@@ -8,7 +8,7 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any, Self, overload
 
-from psygnal import Signal
+from anyenv.signals import Signal
 
 from agentpool.log import get_logger
 from agentpool.messaging import ChatMessage
@@ -53,11 +53,11 @@ class Talk[TTransmittedData = Any]:
         timestamp: datetime = field(default_factory=get_now)
 
     # Original message "coming in"
-    message_received = Signal(ChatMessage)
+    message_received = Signal[ChatMessage[Any]]()
     # After any transformation (one for each message, not per target)
-    message_forwarded = Signal(ChatMessage)
+    message_forwarded = Signal[ChatMessage[Any]]()
     # Comprehensive signal capturing all information about one "message handling process"
-    connection_processed = Signal(ConnectionProcessed)
+    connection_processed = Signal[ConnectionProcessed]()
 
     def __init__(
         self,
@@ -270,7 +270,7 @@ class Talk[TTransmittedData = Any]:
             )
         ]
         # 7. emit connection processed event
-        self.connection_processed.emit(
+        await self.connection_processed.emit(
             self.ConnectionProcessed(
                 message=processed_message,
                 source=self.source,
@@ -283,7 +283,7 @@ class Talk[TTransmittedData = Any]:
         if target_list:
             messages = [*self._stats.messages, processed_message]
             self._stats = replace(self._stats, messages=messages)
-            self.message_forwarded.emit(processed_message)
+            await self.message_forwarded.emit(processed_message)
 
         # 9. Second pass: Actually process for each target
         responses: list[ChatMessage[Any]] = []
@@ -308,10 +308,9 @@ class Talk[TTransmittedData = Any]:
 
         match self.connection_type:
             case "run":
-                prompts: list[PromptCompatible] = [message]
-                if prompt:
-                    prompts.append(prompt)
-                return await target.run(*prompts)
+                # Use run_message to handle ChatMessage routing
+                # It extracts content, preserves conversation_id, and applies forwarding
+                return await target.run_message(message)
 
             case "context":
                 meta = {

agentpool/testing.py

@@ -35,7 +35,7 @@ from typing import TYPE_CHECKING, Any, Literal
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Sequence
 
-    from evented.configs import EventConfig
+    from evented_config import EventConfig
 
     from agentpool.agents.acp_agent import ACPAgent
     from agentpool.common_types import BuiltinEventHandlerType, IndividualEventHandler

agentpool/tool_impls/__init__.py

@@ -0,0 +1,6 @@
+"""Standalone tool implementations.
+
+Each tool is a subclass of Tool that can be used independently or grouped.
+"""
+
+from __future__ import annotations

agentpool/tool_impls/agent_cli/__init__.py

@@ -0,0 +1,42 @@
+"""Agent CLI tool for executing internal commands."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from agentpool.tool_impls.agent_cli.tool import AgentCliTool
+from agentpool_config.tools import ToolHints
+
+
+__all__ = ["AgentCliTool", "create_agent_cli_tool"]
+
+# Tool metadata defaults
+NAME = "agent_cli"
+DESCRIPTION = "Execute an internal agent management command."
+CATEGORY: Literal["other"] = "other"
+HINTS = ToolHints()
+
+
+def create_agent_cli_tool(
+    *,
+    name: str = NAME,
+    description: str = DESCRIPTION,
+    requires_confirmation: bool = False,
+) -> AgentCliTool:
+    """Create a configured AgentCliTool instance.
+
+    Args:
+        name: Tool name override.
+        description: Tool description override.
+        requires_confirmation: Whether tool execution needs confirmation.
+
+    Returns:
+        Configured AgentCliTool instance.
+    """
+    return AgentCliTool(
+        name=name,
+        description=description,
+        category=CATEGORY,
+        hints=HINTS,
+        requires_confirmation=requires_confirmation,
+    )