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

agentpool_config/session.py

@@ -103,9 +103,6 @@ class SessionQuery(Schema):
     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:

agentpool_config/storage.py

@@ -19,7 +19,6 @@ if TYPE_CHECKING:
     from agentpool.sessions.store import SessionStore
 
 
-LogFormat = Literal["chronological", "conversations"]
 FilterMode = Literal["and", "override"]
 
 APP_NAME: Final = "agentpool"
@@ -27,8 +26,10 @@ 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."""
+Generate metadata for this conversation request. Provide:
+- A short, descriptive title (3-7 words)
+- A single emoji that represents the topic
+- An iconify icon name (e.g., 'mdi:code-braces', 'mdi:database', 'mdi:bug')"""
 
 
 def get_database_path() -> str:
@@ -104,38 +105,6 @@ class SQLStorageConfig(BaseStorageProviderConfig):
         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."""
 
@@ -210,13 +179,35 @@ class OpenCodeStorageConfig(BaseStorageProviderConfig):
     """Path to OpenCode storage directory."""
 
 
+class ZedStorageConfig(BaseStorageProviderConfig):
+    """Zed IDE native storage format configuration.
+
+    Reads from Zed's native SQLite + zstd-compressed JSON format.
+    Useful for importing conversation history from Zed's AI assistant.
+
+    This is a READ-ONLY provider - it cannot write back to Zed's format.
+    """
+
+    model_config = ConfigDict(json_schema_extra={"x-doc-title": "Zed Storage"})
+
+    type: Literal["zed"] = Field("zed", init=False)
+    """Zed IDE native storage configuration."""
+
+    path: str = Field(
+        default="~/.local/share/zed/threads/threads.db",
+        examples=["~/.local/share/zed/threads/threads.db", "~/.local/share/zed"],
+        title="Zed threads database path",
+    )
+    """Path to Zed threads database (or parent directory)."""
+
+
 StorageProviderConfig = Annotated[
     SQLStorageConfig
     | FileStorageConfig
-    | TextLogConfig
     | MemoryStorageConfig
     | ClaudeStorageConfig
-    | OpenCodeStorageConfig,
+    | OpenCodeStorageConfig
+    | ZedStorageConfig,
     Field(discriminator="type"),
 ]
 
@@ -282,8 +273,12 @@ class StorageConfig(Schema):
     """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],
+        default="google-gla:gemini-2.5-flash-lite,openrouter:deepseek/deepseek-r1-0528:free",
+        examples=[
+            "google-gla:gemini-2.5-flash-lite",
+            "google-gla:gemini-2.5-flash-lite,openrouter:deepseek/deepseek-r1-0528:free",
+            None,
+        ],
         title="Title generation model",
     )
     """Model to use for generating conversation titles.
@@ -318,6 +313,10 @@ class StorageConfig(Schema):
         from agentpool.sessions.store import MemorySessionStore
         from agentpool_storage.session_store import SQLSessionStore
 
+        # Use memory store during tests
+        if os.getenv("PYTEST_CURRENT_TEST"):
+            return MemorySessionStore()
+
         match self.session_store:
             case "memory":
                 return MemorySessionStore()

agentpool_config/task.py

@@ -23,7 +23,7 @@ class Job[TDeps, TResult = str](Schema):
 
     Requirements:
     - The agent must have compatible dependencies (required_dependency)
-    - The agent must produce the specified result type (required_return_type)
+    - The agent must produce the specified result type (required_output_type)
 
     Equipment:
     - The task provides necessary tools for execution (tools)
@@ -54,7 +54,7 @@ class Job[TDeps, TResult = str](Schema):
     )
     """The task instruction/prompt."""
 
-    required_return_type: ImportString[type[TResult]] = Field(
+    required_output_type: ImportString[type[TResult]] = Field(
         default="str",
         validate_default=True,
         examples=["str", "dict", "builtins:str"],
@@ -120,7 +120,7 @@ class Job[TDeps, TResult = str](Schema):
         ):
             return False
 
-        if agent._output_type != self.required_return_type:
+        if agent._output_type != self.required_output_type:
             return False
 
         # Check vision capabilities

agentpool_config/tools.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Annotated, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import ConfigDict, Field, ImportString
 from schemez import Schema
@@ -56,26 +56,9 @@ class BaseToolConfig(Schema):
     requires_confirmation: bool = Field(default=False, title="Requires confirmation")
     """Whether tool execution needs confirmation."""
 
-    metadata: dict[str, str] = Field(
-        default_factory=dict,
-        examples=[
-            {"category": "web", "version": "1.0"},
-            {"author": "system", "tags": "search,utility"},
-            {"priority": "high", "environment": "production"},
-        ],
-        title="Tool metadata",
-    )
+    metadata: dict[str, str] = Field(default_factory=dict, title="Tool metadata")
     """Additional tool metadata."""
 
-    hints: ToolHints | None = Field(
-        default=None,
-        title="Execution hints",
-        examples=[
-            {"read_only": True, "destructive": False, "open_world": True, "idempotent": False},
-        ],
-    )
-    """Hints for tool execution."""
-
     model_config = ConfigDict(frozen=True)
 
     def get_tool(self) -> Tool:
@@ -95,6 +78,15 @@ class ImportToolConfig(BaseToolConfig):
     )
     """Import path to the tool function."""
 
+    hints: ToolHints | None = Field(
+        default=None,
+        title="Execution hints",
+        examples=[
+            {"read_only": True, "destructive": False, "open_world": True, "idempotent": False},
+        ],
+    )
+    """Hints for tool execution."""
+
     def get_tool(self) -> Tool:
         """Import and create tool from configuration."""
         from agentpool.tools.base import Tool
@@ -107,12 +99,3 @@ class ImportToolConfig(BaseToolConfig):
             requires_confirmation=self.requires_confirmation,
             metadata=self.metadata,
         )
-
-
-from agentpool_config.builtin_tools import BuiltinToolConfig  # noqa: E402
-
-
-ToolConfig = Annotated[
-    ImportToolConfig | BuiltinToolConfig,
-    Field(discriminator="type"),
-]

agentpool_config/toolsets.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING, Annotated, Literal, cast
 
-from exxec.configs import ExecutionEnvironmentConfig
-from llmling_models.configs.model_configs import AnyModelConfig
+from exxec_config import ExecutionEnvironmentConfig
+from llmling_models_config import AnyModelConfig
 from pydantic import ConfigDict, EmailStr, Field, HttpUrl, SecretStr
 from schemez import Schema
-from searchly.config import (
+from searchly_config import (
     NewsSearchProviderConfig,
     NewsSearchProviderName,
     WebSearchProviderConfig,
@@ -18,8 +18,8 @@ from searchly.config import (
 )
 from tokonomics.model_names import ModelId
 from upathtools import UPath
-from upathtools.configs import FilesystemConfigType
-from upathtools.configs.base import FileSystemConfig
+from upathtools_config import FilesystemConfigType
+from upathtools_config.base import FileSystemConfig
 
 from agentpool_config.converters import ConversionConfig
 from agentpool_config.tools import ImportToolConfig
@@ -49,11 +49,10 @@ ExecutionEnvironmentToolName = Literal[
     "list_processes",
 ]
 
-UserInteractionToolName = Literal["ask_user",]
 SkillsToolName = Literal["load_skill", "list_skills"]
 CodeToolName = Literal["format_code", "ast_grep"]
 PlanToolName = Literal["get_plan", "add_plan_entry", "update_plan_entry", "remove_plan_entry"]
-PlanToolMode = Literal["granular", "declarative", "hybrid"]
+PlanToolMode = Literal["granular", "declarative"]
 
 
 class BaseToolsetConfig(Schema):
@@ -235,24 +234,24 @@ class WorkersToolsetConfig(BaseToolsetConfig):
         return WorkersTools(workers=self.workers, name="workers")
 
 
-class ExecutionEnvironmentToolsetConfig(BaseToolsetConfig):
-    """Configuration for execution environment toolset (code + process management)."""
+class ProcessManagementToolsetConfig(BaseToolsetConfig):
+    """Configuration for process management toolset (code + process management)."""
 
     model_config = ConfigDict(
         json_schema_extra={
             "x-icon": "octicon:terminal-16",
-            "x-doc-title": "Execution Environment Toolset",
+            "x-doc-title": "Process management Toolset",
         }
     )
 
-    type: Literal["execution"] = Field("execution", init=False)
-    """Execution environment toolset."""
+    type: Literal["process_management"] = Field("process_management", init=False)
+    """Process management toolset."""
 
     environment: ExecutionEnvironmentConfig | None = Field(
         default=None,
-        title="Execution environment",
+        title="Process management",
     )
-    """Optional execution environment configuration (defaults to local)."""
+    """Optional Process management configuration (defaults to local)."""
 
     tools: dict[ExecutionEnvironmentToolName, bool] | None = Field(
         default=None,
@@ -261,42 +260,11 @@ class ExecutionEnvironmentToolsetConfig(BaseToolsetConfig):
     """Optional tool filter to enable/disable specific tools."""
 
     def get_provider(self) -> ResourceProvider:
-        """Create execution environment tools provider."""
-        from agentpool_toolsets.builtin import ExecutionEnvironmentTools
+        """Create Process management tools provider."""
+        from agentpool_toolsets.builtin import ProcessManagementTools
 
         env = self.environment.get_provider() if self.environment else None
-        provider = ExecutionEnvironmentTools(env=env, name="execution")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
-class UserInteractionToolsetConfig(BaseToolsetConfig):
-    """Configuration for user interaction toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:comment-discussion-16",
-            "x-doc-title": "User Interaction Toolset",
-        }
-    )
-
-    type: Literal["user_interaction"] = Field("user_interaction", init=False)
-    """User interaction toolset."""
-
-    tools: dict[UserInteractionToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create user interaction tools provider."""
-        from agentpool_toolsets.builtin import UserInteractionTools
-
-        provider = UserInteractionTools(name="user_interaction")
+        provider = ProcessManagementTools(env=env, name="process_management")
         if self.tools is not None:
             from agentpool.resource_providers import FilteringResourceProvider
 
@@ -644,41 +612,6 @@ class NotificationsToolsetConfig(BaseToolsetConfig):
         return NotificationsTools(channels=self.channels)
 
 
-class SemanticMemoryToolsetConfig(BaseToolsetConfig):
-    """Configuration for semantic memory / knowledge processing toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:database-16",
-            "x-doc-title": "Semantic Memory Toolset",
-        }
-    )
-
-    type: Literal["semantic_memory"] = Field("semantic_memory", init=False)
-    """Semantic memory toolset using TypeAgent's KnowPro."""
-
-    model: str | ModelId | AnyModelConfig | None = Field(
-        default=None,
-        examples=["openai:gpt-4o", "anthropic:claude-sonnet-4-20250514"],
-        title="Model for LLM sampling",
-    )
-    """Model to use for query translation and answer generation."""
-
-    dbname: str | None = Field(
-        default=None,
-        examples=["knowledge.db", "/path/to/memory.db"],
-        title="Database path",
-    )
-    """SQLite database path for persistent storage, or None for in-memory."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create semantic memory tools provider."""
-        from agentpool_toolsets.semantic_memory_toolset import SemanticMemoryTools
-
-        model = m if isinstance(m := self.model, str) or m is None else m.get_model()
-        return SemanticMemoryTools(model=model, dbname=self.dbname)
-
-
 class CustomToolsetConfig(BaseToolsetConfig):
     """Configuration for custom toolsets."""
 
@@ -847,13 +780,14 @@ class PlanToolsetConfig(BaseToolsetConfig):
     """Plan toolset."""
 
     mode: PlanToolMode = Field(
-        default="granular",
+        default="declarative",
         title="Plan tool mode",
     )
     """Tool mode:
-    - 'granular': Separate tools (get/add/update/remove) - better for simpler models
-    - 'declarative': Single set_plan tool with full list - fewer calls, suits capable models
-    - 'hybrid': Both approaches available - model chooses most efficient per situation
+    - 'declarative': Single set_plan tool with full list (default, recommended)
+      - Fewer calls, better UX with parallel updates
+    - 'granular': Separate tools (get/add/update/remove)
+      - For simpler models or fine-grained control
     """
 
     tools: dict[PlanToolName, bool] | None = Field(
@@ -954,8 +888,7 @@ ToolsetConfig = Annotated[
     OpenAPIToolsetConfig
     | EntryPointToolsetConfig
     | ComposioToolSetConfig
-    | ExecutionEnvironmentToolsetConfig
-    | UserInteractionToolsetConfig
+    | ProcessManagementToolsetConfig
     | SkillsToolsetConfig
     | CodeToolsetConfig
     | FSSpecToolsetConfig
@@ -966,7 +899,6 @@ ToolsetConfig = Annotated[
     | RemoteCodeModeToolsetConfig
     | SearchToolsetConfig
     | NotificationsToolsetConfig
-    | SemanticMemoryToolsetConfig
     | ConfigCreationToolsetConfig
     | ImportToolsToolsetConfig
     | PlanToolsetConfig