agentpool 2.2.2__tar.gz → 2.2.3__tar.gz

{agentpool-2.2.2 → agentpool-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpool
-Version: 2.2.2
+Version: 2.2.3
 Summary: Pydantic-AI based Multi-Agent Framework with YAML-based Agents, Teams, Workflows & Extended ACP / AGUI integration
 Keywords: 
 Author: Philipp Temminghoff
@@ -37,6 +37,7 @@ Requires-Dist: jinjarope
 Requires-Dist: llmling-models>=1.4.1
 Requires-Dist: logfire
 Requires-Dist: mcp>=1.2.0
+Requires-Dist: pillow>=11.3.0
 Requires-Dist: platformdirs
 Requires-Dist: promptantic>=0.4.5
 Requires-Dist: psygnal>=0.11.1

{agentpool-2.2.2 → agentpool-2.2.3}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [project]
 name = "agentpool"
-version = "2.2.2"
+version = "2.2.3"
 description = "Pydantic-AI based Multi-Agent Framework with YAML-based Agents, Teams, Workflows & Extended ACP / AGUI integration"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -45,6 +45,7 @@ dependencies = [
   "llmling-models>=1.4.1",
   "logfire",
   "mcp>=1.2.0",
+  "pillow>=11.3.0",
   "platformdirs",
   "promptantic>=0.4.5",
   "psygnal>=0.11.1",

{agentpool-2.2.2 → agentpool-2.2.3}/src/acp/utils.py

@@ -131,7 +131,7 @@ def generate_tool_title(tool_name: str, tool_input: dict[str, Any]) -> str:  # n
         return f"Editing: {path}"
 
     # Command/script execution - show the command
-    if any(k in name_lower for k in ["command", "execute", "run", "shell", "script"]) and (
+    if any(k in name_lower for k in ["command", "execute", "run", "shell", "script", "bash"]) and (
         cmd := tool_input.get("command")
     ):
         # Truncate long commands
@@ -244,7 +244,7 @@ def infer_tool_kind(tool_name: str) -> ToolCallKind:  # noqa: PLR0911
         return "move"
     if any(i in name_lower for i in ["search", "find", "query", "lookup"]):
         return "search"
-    if any(i in name_lower for i in ["execute", "run", "exec", "command", "shell"]):
+    if any(i in name_lower for i in ["execute", "run", "exec", "command", "shell", "bash"]):
         return "execute"
     if any(i in name_lower for i in ["think", "plan", "reason", "analyze"]):
         return "think"

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/agents/agent.py

@@ -19,20 +19,22 @@ from pydantic import ValidationError
 from pydantic._internal import _typing_extra
 from pydantic_ai import (
     Agent as PydanticAgent,
-    AgentRunResultEvent,
     BaseToolCallPart,
+    CallToolsNode,
     FunctionToolCallEvent,
     FunctionToolResultEvent,
-    PartDeltaEvent,
+    ModelRequestNode,
     PartStartEvent,
     RunContext,
-    TextPart,
-    TextPartDelta,
     ToolReturnPart,
 )
 
 from agentpool.agents.base_agent import BaseAgent
-from agentpool.agents.events import RunStartedEvent, StreamCompleteEvent, ToolCallCompleteEvent
+from agentpool.agents.events import (
+    RunStartedEvent,
+    StreamCompleteEvent,
+    ToolCallCompleteEvent,
+)
 from agentpool.agents.modes import ModeInfo
 from agentpool.log import get_logger
 from agentpool.messaging import ChatMessage, MessageHistory, MessageNode
@@ -51,6 +53,34 @@ from agentpool.utils.streams import FileTracker, merge_queue_into_iterator
 TResult = TypeVar("TResult")
 
 
+def _extract_text_from_messages(
+    messages: list[Any], include_interruption_note: bool = False
+) -> str:
+    """Extract text content from pydantic-ai messages.
+
+    Args:
+        messages: List of ModelRequest/ModelResponse messages
+        include_interruption_note: Whether to append interruption notice
+
+    Returns:
+        Concatenated text content from all ModelResponse TextParts
+    """
+    from pydantic_ai.messages import ModelResponse, TextPart as PydanticTextPart
+
+    content = "".join(
+        part.content
+        for msg in messages
+        if isinstance(msg, ModelResponse)
+        for part in msg.parts
+        if isinstance(part, PydanticTextPart)
+    )
+    if include_interruption_note:
+        if content:
+            content += "\n\n"
+        content += "[Request interrupted by user]"
+    return content
+
+
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Coroutine, Sequence
     from datetime import datetime
@@ -792,9 +822,6 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
         self._cancelled = False
         self._current_stream_task = asyncio.current_task()
 
-        # Track accumulated content for partial message on cancellation
-        accumulated_text: list[str] = []
-
         # Execute pre-run hooks
         if self.hooks:
             pre_run_result = await self.hooks.run_pre_run_hooks(
@@ -815,6 +842,8 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
         await handler(None, run_started)
         yield run_started
         try:
+            from pydantic_graph import End
+
             agentlet = await self.get_agentlet(tool_choice, model, output_type, input_provider)
             content = await convert_prompts(prompts)
             response_msg: ChatMessage[Any] | None = None
@@ -823,104 +852,104 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
 
             # Use provided usage_limits or fall back to default
             effective_limits = usage_limits or self._default_usage_limits
+            history = [m for run in history_list for m in run.to_pydantic_ai()]
+
+            # Track tool call starts to combine with results later
+            pending_tcs: dict[str, BaseToolCallPart] = {}
+            file_tracker = FileTracker()
 
-            stream_events = agentlet.run_stream_events(
+            async with agentlet.iter(
                 converted,
                 deps=deps,  # type: ignore[arg-type]
-                message_history=[m for run in history_list for m in run.to_pydantic_ai()],
+                message_history=history,
                 usage_limits=effective_limits,
                 instructions=instructions,
-            )
-
-            # Stream events through merge_queue for progress events
-            file_tracker = FileTracker()
-            async with merge_queue_into_iterator(stream_events, self._event_queue) as events:
-                # Track tool call starts to combine with results later
-                pending_tcs: dict[str, BaseToolCallPart] = {}
+            ) as agent_run:
                 try:
-                    async for event in file_tracker.track(events):
-                        # Check for cancellation
+                    async for node in agent_run:
                         if self._cancelled:
                             self.log.info("Stream cancelled by user")
                             break
+                        if isinstance(node, End):
+                            break
 
-                        # Call event handlers for all events
-                        await handler(None, event)
-                        yield event  # type: ignore[misc]
-
-                        # Accumulate text content for partial message
-                        match event:
-                            case PartDeltaEvent(delta=TextPartDelta(content_delta=delta)):
-                                accumulated_text.append(delta)
-                            case PartStartEvent(part=TextPart(content=text)) if text:
-                                accumulated_text.append(text)
-
-                        match event:
-                            case (
-                                PartStartEvent(part=BaseToolCallPart() as tool_part)
-                                | FunctionToolCallEvent(part=tool_part)
+                        # Stream events from model request node
+                        if isinstance(node, ModelRequestNode):
+                            async with (
+                                node.stream(agent_run.ctx) as agent_stream,
+                                merge_queue_into_iterator(
+                                    agent_stream,  # type: ignore[arg-type]
+                                    self._event_queue,
+                                ) as merged,
+                            ):
+                                async for event in file_tracker.track(merged):
+                                    if self._cancelled:
+                                        break
+                                    await handler(None, event)
+                                    yield event
+                                    combined = self._process_tool_event(
+                                        event, pending_tcs, message_id
+                                    )
+                                    if combined:
+                                        await handler(None, combined)
+                                        yield combined
+
+                        # Stream events from tool call node
+                        elif isinstance(node, CallToolsNode):
+                            async with (
+                                node.stream(agent_run.ctx) as tool_stream,
+                                merge_queue_into_iterator(tool_stream, self._event_queue) as merged,
                             ):
-                                # Store tool call start info for later combination with result
-                                pending_tcs[tool_part.tool_call_id] = tool_part
-                            case FunctionToolResultEvent(tool_call_id=call_id) as result_event:
-                                # Check if we have a pending tool call to combine with
-                                if call_info := pending_tcs.pop(call_id, None):
-                                    # Create and yield combined event
-                                    combined_event = ToolCallCompleteEvent(
-                                        tool_name=call_info.tool_name,
-                                        tool_call_id=call_id,
-                                        tool_input=safe_args_as_dict(call_info),
-                                        tool_result=result_event.result.content
-                                        if isinstance(result_event.result, ToolReturnPart)
-                                        else result_event.result,
-                                        agent_name=self.name,
-                                        message_id=message_id,
+                                async for event in file_tracker.track(merged):
+                                    if self._cancelled:
+                                        break
+                                    await handler(None, event)
+                                    yield event
+                                    combined = self._process_tool_event(
+                                        event, pending_tcs, message_id
                                     )
-                                    await handler(None, combined_event)
-                                    yield combined_event
-                            case AgentRunResultEvent():
-                                # Capture final result data, Build final response message
-                                response_time = time.perf_counter() - start_time
-                                response_msg = await ChatMessage.from_run_result(
-                                    event.result,
-                                    agent_name=self.name,
-                                    message_id=message_id,
-                                    conversation_id=conversation_id or user_msg.conversation_id,
-                                    parent_id=user_msg.message_id,
-                                    response_time=response_time,
-                                    metadata=file_tracker.get_metadata(),
-                                )
+                                    if combined:
+                                        await handler(None, combined)
+                                        yield combined
                 except asyncio.CancelledError:
                     self.log.info("Stream cancelled via task cancellation")
                     self._cancelled = True
 
-            # Handle cancellation - emit partial message
-            if self._cancelled:
+                # Build response message
                 response_time = time.perf_counter() - start_time
-                partial_content = "".join(accumulated_text)
-                if partial_content:
-                    partial_content += "\n\n"
-                partial_content += "[Request interrupted by user]"
-                response_msg = ChatMessage(
-                    content=partial_content,
-                    role="assistant",
-                    name=self.name,
-                    message_id=message_id,
-                    conversation_id=conversation_id or user_msg.conversation_id,
-                    parent_id=user_msg.message_id,
-                    response_time=response_time,
-                    finish_reason="stop",
-                )
-                complete_event = StreamCompleteEvent(message=response_msg)
-                await handler(None, complete_event)
-                yield complete_event
-                self._current_stream_task = None
-                return
-
-            # Only finalize if we got a result (stream may exit early on error)
-            if response_msg is None:
-                msg = "Stream completed without producing a result"
-                raise RuntimeError(msg)  # noqa: TRY301
+                if self._cancelled:
+                    partial_content = _extract_text_from_messages(
+                        agent_run.all_messages(), include_interruption_note=True
+                    )
+                    response_msg = ChatMessage(
+                        content=partial_content,
+                        role="assistant",
+                        name=self.name,
+                        message_id=message_id,
+                        conversation_id=conversation_id or user_msg.conversation_id,
+                        parent_id=user_msg.message_id,
+                        response_time=response_time,
+                        finish_reason="stop",
+                    )
+                    complete_event = StreamCompleteEvent(message=response_msg)
+                    await handler(None, complete_event)
+                    yield complete_event
+                    self._current_stream_task = None
+                    return
+
+                if agent_run.result:
+                    response_msg = await ChatMessage.from_run_result(
+                        agent_run.result,
+                        agent_name=self.name,
+                        message_id=message_id,
+                        conversation_id=conversation_id or user_msg.conversation_id,
+                        parent_id=user_msg.message_id,
+                        response_time=response_time,
+                        metadata=file_tracker.get_metadata(),
+                    )
+                else:
+                    msg = "Stream completed without producing a result"
+                    raise RuntimeError(msg)  # noqa: TRY301
 
             # Execute post-run hooks
             if self.hooks:
@@ -954,6 +983,41 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
         finally:
             self._current_stream_task = None
 
+    def _process_tool_event(
+        self,
+        event: RichAgentStreamEvent[Any],
+        pending_tool_calls: dict[str, BaseToolCallPart],
+        message_id: str,
+    ) -> ToolCallCompleteEvent | None:
+        """Process tool-related events and return combined event when complete.
+
+        Args:
+            event: The streaming event to process
+            pending_tool_calls: Dict tracking in-progress tool calls by ID
+            message_id: Message ID for the combined event
+
+        Returns:
+            ToolCallCompleteEvent if a tool call completed, None otherwise
+        """
+        match event:
+            case PartStartEvent(part=BaseToolCallPart() as tool_part):
+                pending_tool_calls[tool_part.tool_call_id] = tool_part
+            case FunctionToolCallEvent(part=tool_part):
+                pending_tool_calls[tool_part.tool_call_id] = tool_part
+            case FunctionToolResultEvent(tool_call_id=call_id) as result_event:
+                if call_info := pending_tool_calls.pop(call_id, None):
+                    return ToolCallCompleteEvent(
+                        tool_name=call_info.tool_name,
+                        tool_call_id=call_id,
+                        tool_input=safe_args_as_dict(call_info),
+                        tool_result=result_event.result.content
+                        if isinstance(result_event.result, ToolReturnPart)
+                        else result_event.result,
+                        agent_name=self.name,
+                        message_id=message_id,
+                    )
+        return None
+
     async def run_iter(
         self,
         *prompt_groups: Sequence[PromptCompatible],

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/models/acp_agents/mcp_capable.py

@@ -211,9 +211,9 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Fallback model when default is overloaded."""
 
-    dangerously_skip_permissions: bool = Field(
+    auto_approve: bool = Field(
         default=False,
-        title="Dangerously Skip Permissions",
+        title="Auto Approve",
     )
     """Bypass all permission checks. Only for sandboxed environments."""
 
@@ -267,7 +267,7 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
                 args.extend(["--tools", ""])
         if self.fallback_model:
             args.extend(["--fallback-model", self.fallback_model])
-        if self.dangerously_skip_permissions:
+        if self.auto_approve:
             args.append("--dangerously-skip-permissions")
         if self.output_type:
             args.extend(["--output-format", "json"])
@@ -606,7 +606,7 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Working directory for the agent."""
 
-    yolo: bool = Field(default=False, title="YOLO")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Automatically approve all actions."""
 
     thinking: bool | None = Field(default=None, title="Thinking")
@@ -636,7 +636,7 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
         if mcp_json:
             args.extend(["--mcp-config", mcp_json])
 
-        if self.yolo:
+        if self.auto_approve:
             args.append("--yolo")
         if self.thinking is not None and self.thinking:
             args.append("--thinking")

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/models/acp_agents/non_mcp.py

@@ -66,6 +66,12 @@ class CodexACPAgentConfig(BaseACPAgentConfig):
     )
     """Model override."""
 
+    auto_approve: bool = Field(
+        default=False,
+        title="Auto Approve",
+    )
+    """Automatically accept all actions (YOLO mode)."""
+
     sandbox_permissions: list[str] | None = Field(
         default=None,
         title="Sandbox Permissions",
@@ -99,6 +105,8 @@ class CodexACPAgentConfig(BaseACPAgentConfig):
                 "-c",
                 f"shell_environment_policy.inherit={self.shell_environment_policy_inherit}",
             ])
+        if self.auto_approve:
+            args.extend(["-c", "approval_mode=yolo"])
 
         return args
 
@@ -603,7 +611,7 @@ class VTCodeACPAgentConfig(BaseACPAgentConfig):
     )
     """Configuration file path."""
 
-    skip_confirmations: bool = Field(default=False, title="Skip Confirmations")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Skip safety confirmations."""
 
     full_auto: bool = Field(default=False, title="Full Auto")
@@ -643,7 +651,7 @@ class VTCodeACPAgentConfig(BaseACPAgentConfig):
             args.extend(["--max-tool-calls", str(self.max_tool_calls)])
         if self.config:
             args.extend(["--config", self.config])
-        if self.skip_confirmations:
+        if self.auto_approve:
             args.append("--skip-confirmations")
         if self.full_auto:
             args.append("--full-auto")
@@ -807,7 +815,7 @@ class GeminiACPAgentConfig(BaseACPAgentConfig):
     sandbox: bool = Field(default=False, title="Sandbox")
     """Run in sandbox mode."""
 
-    yolo: bool = Field(default=False, title="YOLO")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Automatically accept all actions."""
 
     allowed_tools: list[str] | None = Field(
@@ -859,7 +867,7 @@ class GeminiACPAgentConfig(BaseACPAgentConfig):
             args.extend(["--approval-mode", self.approval_mode])
         if self.sandbox:
             args.append("--sandbox")
-        if self.yolo:
+        if self.auto_approve:
             args.append("--yolo")
         if self.allowed_tools:
             args.extend(["--allowed-tools", *self.allowed_tools])

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/resource_providers/plan_provider.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.resource_providers import ResourceProvider
@@ -18,6 +18,7 @@ if TYPE_CHECKING:
 # Keep PlanEntry for backward compatibility with event emitting
 PlanEntryPriority = Literal["high", "medium", "low"]
 PlanEntryStatus = Literal["pending", "in_progress", "completed"]
+PlanToolMode = Literal["granular", "declarative", "hybrid"]
 
 
 @dataclass(kw_only=True)
@@ -58,9 +59,15 @@ class PlanProvider(ResourceProvider):
 
     kind = "tools"
 
-    def __init__(self) -> None:
-        """Initialize plan provider."""
+    def __init__(self, mode: PlanToolMode = "granular") -> None:
+        """Initialize plan provider.
+
+        Args:
+            mode: Tool mode - 'granular' for separate tools, 'declarative' for
+                  single set_plan tool, 'hybrid' for both approaches.
+        """
         super().__init__(name="plan")
+        self.mode = mode
 
     def _get_tracker(self, agent_ctx: AgentContext) -> TodoTracker | None:
         """Get the TodoTracker from the pool."""
@@ -69,13 +76,29 @@ class PlanProvider(ResourceProvider):
         return None
 
     async def get_tools(self) -> list[Tool]:
-        """Get plan management tools."""
-        return [
-            self.create_tool(self.get_plan, category="read"),
-            self.create_tool(self.add_plan_entry, category="other"),
-            self.create_tool(self.update_plan_entry, category="edit"),
-            self.create_tool(self.remove_plan_entry, category="delete"),
-        ]
+        """Get plan management tools based on mode."""
+        tools: list[Tool] = [self.create_tool(self.get_plan, category="read")]
+
+        if self.mode == "declarative":
+            # Single bulk tool for capable models
+            tools.append(self.create_tool(self.set_plan, category="other"))
+        elif self.mode == "hybrid":
+            # Both approaches - model chooses
+            tools.extend([
+                self.create_tool(self.set_plan, category="other"),
+                self.create_tool(self.add_plan_entry, category="other"),
+                self.create_tool(self.update_plan_entry, category="edit"),
+                self.create_tool(self.remove_plan_entry, category="delete"),
+            ])
+        else:
+            # granular mode (default) - separate tools for simpler models
+            tools.extend([
+                self.create_tool(self.add_plan_entry, category="other"),
+                self.create_tool(self.update_plan_entry, category="edit"),
+                self.create_tool(self.remove_plan_entry, category="delete"),
+            ])
+
+        return tools
 
     async def get_plan(self, agent_ctx: AgentContext) -> str:
         """Get the current plan formatted as markdown.
@@ -108,6 +131,47 @@ class PlanProvider(ResourceProvider):
 
         return "\n".join(lines)
 
+    async def set_plan(
+        self,
+        agent_ctx: AgentContext,
+        entries: list[dict[str, Any]],
+    ) -> str:
+        """Replace the entire plan with new entries (declarative/bulk update).
+
+        This is more efficient than multiple add/update calls when setting
+        or significantly modifying the plan.
+
+        Args:
+            agent_ctx: Agent execution context
+            entries: List of plan entries, each with:
+                - content (str, required): Task description
+                - priority (str, optional): "high", "medium", or "low" (default: "medium")
+                - status (str, optional): "pending", "in_progress", or "completed"
+                  (default: "pending")
+
+        Returns:
+            Success message indicating plan was updated
+        """
+        tracker = self._get_tracker(agent_ctx)
+        if tracker is None:
+            return "Error: No pool available for plan tracking"
+
+        # Clear existing entries
+        tracker.clear()
+
+        # Add all new entries
+        for entry in entries:
+            content = entry.get("content", "")
+            if not content:
+                continue
+            priority = entry.get("priority", "medium")
+            status = entry.get("status", "pending")
+            tracker.add(content, priority=priority, status=status)
+
+        await self._emit_plan_update(agent_ctx)
+
+        return f"Plan updated with {len(tracker.entries)} entries"
+
     async def add_plan_entry(
         self,
         agent_ctx: AgentContext,

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/sessions/__init__.py

@@ -1,12 +1,13 @@
 """Session management package."""
 
-from agentpool.sessions.models import SessionData
+from agentpool.sessions.models import ProjectData, SessionData
 from agentpool.sessions.store import SessionStore
 from agentpool.sessions.manager import SessionManager
 from agentpool.sessions.session import ClientSession
 
 __all__ = [
     "ClientSession",
+    "ProjectData",
     "SessionData",
     "SessionManager",
     "SessionStore",

{agentpool-2.2.2 → agentpool-2.2.3}/src/agentpool/sessions/manager.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 
     from agentpool.delegation.pool import AgentPool
     from agentpool.sessions.store import SessionStore
+    from agentpool.storage.manager import StorageManager
 
 logger = get_logger(__name__)
 
@@ -37,6 +38,7 @@ class SessionManager:
         pool: AgentPool[Any],
         store: SessionStore | None = None,
         pool_id: str | None = None,
+        storage: StorageManager | None = None,
     ) -> None:
         """Initialize session manager.
 
@@ -44,10 +46,12 @@ class SessionManager:
             pool: Agent pool for agent access
             store: Session persistence backend (defaults to MemorySessionStore)
             pool_id: Optional identifier for this pool (for multi-pool setups)
+            storage: Optional storage manager for project tracking
         """
         self._pool = pool
         self._store = store or MemorySessionStore()
         self._pool_id = pool_id
+        self._storage = storage
         self._active: dict[str, ClientSession] = {}
         self._lock = asyncio.Lock()
         logger.debug("Initialized session manager", pool_id=pool_id)
@@ -145,12 +149,31 @@ class SessionManager:
                 msg = f"Session '{session_id}' already exists"
                 raise ValueError(msg)
 
+            # Get or create project if cwd provided and storage available
+            project_id: str | None = None
+            if cwd and self._storage:
+                try:
+                    from agentpool_storage.project_store import ProjectStore
+
+                    project_store = ProjectStore(self._storage)
+                    project = await project_store.get_or_create(cwd)
+                    project_id = project.project_id
+                    logger.debug(
+                        "Associated session with project",
+                        session_id=session_id,
+                        project_id=project_id,
+                        worktree=project.worktree,
+                    )
+                except Exception:
+                    logger.exception("Failed to create/get project for session")
+
             # Create session data
             data = SessionData(
                 session_id=session_id,
                 agent_name=agent_name,
                 conversation_id=conversation_id or f"conv_{uuid4().hex[:12]}",
                 pool_id=self._pool_id,
+                project_id=project_id,
                 cwd=cwd,
                 metadata=metadata or {},
             )