agentpool 2.1.9__py3-none-any.whl

agentpool_config/session.py

@@ -0,0 +1,119 @@
+"""Memory configuration for agent memory and history handling."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Self
+from uuid import UUID
+
+from pydantic import ConfigDict, Field
+from schemez import Schema
+
+
+MessageRole = Literal["user", "assistant"]
+
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+
+class MemoryConfig(Schema):
+    """Configuration for agent memory and history handling."""
+
+    enable: bool = Field(default=True, title="Enable memory")
+    """Whether to enable history tracking."""
+
+    max_tokens: int | None = Field(
+        default=None,
+        examples=[1000, 4000, 8000],
+        title="Maximum context tokens",
+    )
+    """Maximum number of tokens to keep in context window."""
+
+    max_messages: int | None = Field(
+        default=None,
+        examples=[10, 50, 100],
+        title="Maximum message count",
+    )
+    """Maximum number of messages to keep in context window."""
+
+    session: SessionQuery | None = Field(default=None, title="Session query")
+    """Query configuration for loading previous session."""
+
+    provider: str | None = Field(
+        default=None,
+        examples=["sqlite", "memory", "file"],
+        title="Storage provider",
+    )
+    """Override default storage provider for this agent.
+    If None, uses manifest's default provider or first available."""
+
+    model_config = ConfigDict(frozen=True)
+
+    @classmethod
+    def from_value(cls, value: bool | int | str | SessionQuery | UUID | None) -> Self:
+        """Create MemoryConfig from any value."""
+        match value:
+            case False:
+                return cls(max_messages=0)
+            case int():
+                return cls(max_tokens=value)
+            case str() | UUID():
+                return cls(session=SessionQuery(name=str(value)))
+            case SessionQuery():
+                return cls(session=value)
+            case None | True:
+                return cls()
+            case _:
+                raise ValueError(f"Invalid memory configuration: type: {value}")
+
+
+class SessionQuery(Schema):
+    """Query configuration for session recovery."""
+
+    name: str | None = Field(
+        default=None,
+        examples=["main_session", "user_123", "conversation_01"],
+        title="Session name",
+    )
+    """Session identifier to match."""
+
+    agents: set[str] | None = Field(default=None, title="Agent filter")
+    """Filter by agent names."""
+
+    since: str | None = Field(
+        default=None,
+        examples=["1h", "2d", "1w"],
+        title="Time period lookback",
+    )
+    """Time period to look back (e.g. "1h", "2d")."""
+
+    until: str | None = Field(default=None, examples=["1h", "2d", "1w"], title="Time period limit")
+    """Time period to look up to."""
+
+    contains: str | None = Field(
+        default=None,
+        examples=["error", "important", "task completed"],
+        title="Content filter",
+    )
+    """Filter by message content."""
+
+    roles: set[MessageRole] | None = Field(default=None, title="Role filter")
+    """Only include specific message roles."""
+
+    limit: int | None = Field(default=None, examples=[10, 50, 100], title="Message limit")
+    """Maximum number of messages to return."""
+
+    include_forwarded: bool = Field(default=True, title="Include forwarded messages")
+    """Whether to include messages forwarded through agents."""
+
+    model_config = ConfigDict(frozen=True)
+
+    def get_time_cutoff(self) -> datetime | None:
+        """Get datetime from time period string."""
+        from agentpool.utils.now import get_now
+        from agentpool.utils.parse_time import parse_time_period
+
+        if not self.since:
+            return None
+        delta = parse_time_period(self.since)
+        return get_now() - delta

agentpool_config/skills.py

@@ -0,0 +1,17 @@
+"""Skills configuration."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Skill:
+    """Skill configuration."""
+
+    url: str
+    name: str
+
+
+dev_browser = Skill(
+    url="https://github.com/SawyerHood/dev-browser/tree/main/skills/dev-browser",
+    name="dev-browser",
+)

agentpool_config/storage.py

@@ -0,0 +1,288 @@
+"""Storage configuration."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, Final, Literal
+
+from platformdirs import user_data_dir
+from pydantic import ConfigDict, Field
+from schemez import Schema
+from tokonomics.model_names import ModelId
+from yamling import FormatType
+
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncEngine
+
+    from agentpool.sessions.store import SessionStore
+
+
+LogFormat = Literal["chronological", "conversations"]
+FilterMode = Literal["and", "override"]
+
+APP_NAME: Final = "agentpool"
+APP_AUTHOR: Final = "agentpool"
+DATA_DIR: Final = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+DEFAULT_DB_NAME: Final = "history.db"
+DEFAULT_TITLE_PROMPT: Final = """\
+Generate a short, descriptive title (3-7 words) for this request. \
+Only respond with the title, nothing else."""
+
+
+def get_database_path() -> str:
+    """Get the database file path, creating directories if needed."""
+    db_path = DATA_DIR / DEFAULT_DB_NAME
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    return f"sqlite:///{db_path}"
+
+
+class BaseStorageProviderConfig(Schema):
+    """Base storage provider configuration."""
+
+    type: str = Field(init=False)
+    """Storage provider type."""
+
+    log_messages: bool = Field(default=True, title="Log messages")
+    """Whether to log messages"""
+
+    agents: set[str] | None = Field(default=None, title="Agent filter")
+    """Optional set of agent names to include. If None, logs all agents."""
+
+    log_conversations: bool = Field(default=True, title="Log conversations")
+    """Whether to log conversations"""
+
+    log_commands: bool = Field(default=True, title="Log commands")
+    """Whether to log command executions"""
+
+    log_context: bool = Field(default=True, title="Log context")
+    """Whether to log context messages."""
+
+
+class SQLStorageConfig(BaseStorageProviderConfig):
+    """SQL database storage configuration."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "SQL Storage"})
+
+    type: Literal["sql"] = Field("sql", init=False)
+    """SQLModel storage configuration."""
+
+    url: str = Field(
+        default_factory=get_database_path,
+        examples=["sqlite:///history.db", "postgresql://user:pass@localhost/db"],
+        title="Database URL",
+    )
+    """Database URL (e.g. sqlite:///history.db)"""
+
+    pool_size: int = Field(
+        default=5,
+        ge=1,
+        examples=[5, 10, 20],
+        title="Connection pool size",
+    )
+    """Connection pool size"""
+
+    auto_migration: bool = Field(default=True, title="Auto migration")
+    """Whether to automatically add missing columns"""
+
+    def get_engine(self) -> AsyncEngine:
+        from sqlalchemy.ext.asyncio import create_async_engine
+
+        # Convert URL to async format
+        url_str = str(self.url)
+        if url_str.startswith("sqlite://"):
+            url_str = url_str.replace("sqlite://", "sqlite+aiosqlite://", 1)
+        elif url_str.startswith("postgresql://"):
+            url_str = url_str.replace("postgresql://", "postgresql+asyncpg://", 1)
+        elif url_str.startswith("mysql://"):
+            url_str = url_str.replace("mysql://", "mysql+aiomysql://", 1)
+
+        # SQLite doesn't support pool_size parameter
+        if url_str.startswith("sqlite+aiosqlite://"):
+            return create_async_engine(url_str)
+        return create_async_engine(url_str, pool_size=self.pool_size)
+
+
+class TextLogConfig(BaseStorageProviderConfig):
+    """Text log configuration."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Text Log"})
+
+    type: Literal["text_file"] = Field("text_file", init=False)
+    """Text log storage configuration."""
+
+    path: str = Field(
+        examples=["/var/log/agent.log", "~/logs/conversations.txt"],
+        title="Log file path",
+    )
+    """Path to log file"""
+
+    format: LogFormat = Field(
+        default="chronological",
+        examples=["chronological", "conversations"],
+        title="Log format",
+    )
+    """Log format template to use"""
+
+    template: Literal["chronological", "conversations"] | str | None = Field(  # noqa: PYI051
+        default="chronological",
+        examples=["chronological", "conversations", "/path/to/template.j2"],
+        title="Template",
+    )
+    """Template to use: either predefined name or path to custom template"""
+
+    encoding: str = Field(default="utf-8", examples=["utf-8", "ascii"], title="File encoding")
+    """File encoding"""
+
+
+class FileStorageConfig(BaseStorageProviderConfig):
+    """File storage configuration."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "File Storage"})
+
+    type: Literal["file"] = Field("file", init=False)
+    """File storage configuration."""
+
+    path: str = Field(
+        examples=["/data/storage.json", "~/agent_data.yaml"],
+        title="Storage file path",
+    )
+    """Path to storage file (extension determines format unless specified)"""
+
+    format: FormatType = Field(
+        default="auto",
+        examples=["auto", "json", "yaml", "toml"],
+        title="Storage format",
+    )
+    """Storage format (auto=detect from extension)"""
+
+    encoding: str = Field(default="utf-8", examples=["utf-8", "ascii"], title="File encoding")
+    """File encoding of the storage file."""
+
+
+class MemoryStorageConfig(BaseStorageProviderConfig):
+    """In-memory storage configuration for testing."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Memory Storage"})
+
+    type: Literal["memory"] = Field("memory", init=False)
+    """In-memory storage configuration for testing."""
+
+
+StorageProviderConfig = Annotated[
+    SQLStorageConfig | FileStorageConfig | TextLogConfig | MemoryStorageConfig,
+    Field(discriminator="type"),
+]
+
+
+SessionStoreType = Literal["sql", "memory"]
+
+
+class StorageConfig(Schema):
+    """Global storage configuration.
+
+    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/storage_configuration/
+    """
+
+    providers: list[StorageProviderConfig] | None = Field(
+        default=None,
+        title="Storage providers",
+        examples=[[{"type": "file", "path": "/data/storage.json"}]],
+    )
+    """List of configured storage providers"""
+
+    session_store: SessionStoreType = Field(
+        default="sql",
+        title="Session store type",
+        examples=["sql", "memory"],
+    )
+    """Type of session store to use for session persistence.
+
+    - "sql": Persist sessions to SQL database (uses same URL as SQL provider)
+    - "memory": In-memory storage (sessions lost on restart)
+    """
+
+    default_provider: str | None = Field(
+        default=None,
+        examples=["sql", "file", "memory"],
+        title="Default provider",
+    )
+    """Name of default provider for history queries.
+    If None, uses first configured provider."""
+
+    agents: set[str] | None = Field(default=None, title="Global agent filter")
+    """Global agent filter. Can be overridden by provider-specific filters."""
+
+    filter_mode: FilterMode = Field(
+        default="and",
+        examples=["and", "override"],
+        title="Filter mode",
+    )
+    """How to combine global and provider agent filters:
+    - "and": Both global and provider filters must allow the agent
+    - "override": Provider filter overrides global filter if set
+    """
+
+    log_messages: bool = Field(default=True, title="Log messages")
+    """Whether to log messages."""
+
+    log_conversations: bool = Field(default=True, title="Log conversations")
+    """Whether to log conversations."""
+
+    log_commands: bool = Field(default=True, title="Log commands")
+    """Whether to log command executions."""
+
+    log_context: bool = Field(default=True, title="Log context")
+    """Whether to log additions to the context."""
+
+    title_generation_model: ModelId | str | None = Field(
+        default="google-gla:gemini-2.5-flash-lite",
+        examples=["google-gla:gemini-2.5-flash-lite", None],
+        title="Title generation model",
+    )
+    """Model to use for generating conversation titles.
+    Set to None to disable automatic title generation."""
+
+    title_generation_prompt: str = Field(
+        default=DEFAULT_TITLE_PROMPT,
+        examples=[DEFAULT_TITLE_PROMPT, "Summarize this given request in 5 words"],
+        title="Title generation prompt",
+    )
+    """Prompt template for generating conversation titles."""
+
+    model_config = ConfigDict(frozen=True)
+
+    @property
+    def effective_providers(self) -> list[StorageProviderConfig]:
+        """Get effective list of providers.
+
+        Returns:
+            - Default SQLite provider if providers is None
+            - Empty list if providers is empty list
+            - Configured providers otherwise
+        """
+        if self.providers is None:
+            if os.getenv("PYTEST_CURRENT_TEST"):
+                return [MemoryStorageConfig()]
+            return [SQLStorageConfig()]
+        return self.providers
+
+    def get_session_store(self) -> SessionStore:
+        """Create session store based on configuration."""
+        from agentpool.sessions.store import MemorySessionStore
+        from agentpool_storage.session_store import SQLSessionStore
+
+        match self.session_store:
+            case "memory":
+                return MemorySessionStore()
+            case "sql":
+                # Find SQL config or use default
+                sql_config = None
+                for provider in self.effective_providers:
+                    if isinstance(provider, SQLStorageConfig):
+                        sql_config = provider
+                        break
+                if sql_config is None:
+                    sql_config = SQLStorageConfig()
+                return SQLSessionStore(sql_config)

agentpool_config/system_prompts.py

@@ -0,0 +1,190 @@
+"""System prompts configuration for agents."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Annotated, Any, Literal
+
+from pydantic import ConfigDict, Field, ImportString
+from schemez import Schema
+
+from agentpool_config.prompt_hubs import PromptHubConfig
+
+
+SystemPromptCategory = Literal["role", "methodology", "quality", "task"]
+
+DEFAULT_TEMPLATE = """
+{%- for prompt in role_prompts %}
+Role: {{ prompt.content }}
+{%- endfor %}
+
+{%- for prompt in methodology_prompts %}
+Method: {{ prompt.content }}
+{%- endfor %}
+
+{%- for prompt in quality_prompts %}
+Quality Check: {{ prompt.content }}
+{%- endfor %}
+
+{%- for prompt in task_prompts %}
+Task: {{ prompt.content }}
+{%- endfor %}
+"""
+
+
+class BaseSystemPrompt(Schema):
+    """Individual system prompt definition."""
+
+    content: str = Field(
+        examples=["You are a helpful assistant", "Always be concise"],
+        title="Prompt content",
+    )
+    """The actual prompt text."""
+
+    category: SystemPromptCategory = Field(
+        default="role",
+        examples=["role", "methodology", "quality", "task"],
+        title="Prompt category",
+    )
+    """Categorization for template organization."""
+
+
+class StaticPromptConfig(BaseSystemPrompt):
+    """Configuration for a static text prompt."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Static Prompt"})
+
+    type: Literal["static"] = Field("static", init=False)
+    """Static prompt reference."""
+
+    content: str = Field(
+        examples=["You are a helpful assistant", "Always be concise"],
+        title="Prompt content",
+    )
+    """The prompt text content."""
+
+
+class FilePromptConfig(BaseSystemPrompt):
+    """Configuration for a file-based Jinja template prompt."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "File Prompt"})
+
+    type: Literal["file"] = Field("file", init=False)
+    """File prompt reference."""
+
+    path: str = Field(
+        examples=["prompts/system.j2", "/templates/agent_prompt.jinja"],
+        title="Template file path",
+    )
+    """Path to the Jinja template file."""
+
+    variables: dict[str, Any] = Field(default_factory=dict, title="Template variables")
+    """Variables to pass to the template."""
+
+
+class LibraryPromptConfig(Schema):
+    """Configuration for a library reference prompt."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Library Prompt"})
+
+    type: Literal["library"] = Field("library", init=False)
+    """Library prompt reference."""
+
+    reference: str = Field(
+        examples=["coding_assistant", "helpful_agent", "creative_writer"],
+        title="Library reference",
+    )
+    """Library prompt reference identifier."""
+
+
+class FunctionPromptConfig(BaseSystemPrompt):
+    """Configuration for a function-generated prompt."""
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Function Prompt"})
+
+    type: Literal["function"] = Field("function", init=False)
+    """Function prompt reference."""
+
+    function: ImportString[Callable[..., str]] = Field(
+        examples=["mymodule.generate_prompt", "prompts.dynamic:create_system_prompt"],
+        title="Function import path",
+    )
+    """Import path to the function that generates the prompt."""
+
+    arguments: dict[str, Any] = Field(default_factory=dict, title="Function arguments")
+    """Arguments to pass to the function."""
+
+
+PromptConfig = Annotated[
+    StaticPromptConfig | FilePromptConfig | LibraryPromptConfig | FunctionPromptConfig,
+    Field(discriminator="type"),
+]
+"""Union type for different prompt configuration types."""
+
+
+class PromptLibraryConfig(Schema):
+    """Complete prompt configuration.
+
+    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/prompt_configuration/
+    """
+
+    system_prompts: dict[str, StaticPromptConfig] = Field(
+        default_factory=dict,
+        title="System prompt definitions",
+    )
+    """Mapping of system prompt identifiers to their definitions."""
+
+    template: str | None = Field(
+        default=None,
+        examples=["Role: {{role}}\nMethod: {{method}}", "{{content}}"],
+        title="Combination template",
+    )
+    """Optional template for combining prompts.
+    Has access to prompts grouped by type."""
+
+    providers: list[PromptHubConfig] = Field(
+        default_factory=list,
+        examples=[
+            [
+                {
+                    "type": "promptlayer",
+                    "api_key": "pl_abc123",
+                }
+            ],
+            [
+                {
+                    "type": "fabric",
+                }
+            ],
+        ],
+        title="Prompt hub providers",
+    )
+    """List of external prompt providers to use."""
+
+    def format_prompts(self, identifiers: list[str] | None = None) -> str:
+        """Format selected prompts using template.
+
+        Args:
+            identifiers: Optional list of prompt IDs to include.
+                       If None, includes all prompts.
+        """
+        # Filter prompts if identifiers provided
+        prompts = (
+            {k: v for k, v in self.system_prompts.items() if k in identifiers}
+            if identifiers
+            else self.system_prompts
+        )
+
+        # Group prompts by type for template
+        by_type = {
+            "role_prompts": [p for p in prompts.values() if p.category == "role"],
+            "methodology_prompts": [p for p in prompts.values() if p.category == "methodology"],
+            "quality_prompts": [p for p in prompts.values() if p.category == "quality"],
+            "task_prompts": [p for p in prompts.values() if p.category == "task"],
+        }
+
+        # Render template
+        from jinja2 import Template
+
+        template = Template(self.template or DEFAULT_TEMPLATE)
+        return template.render(**by_type)