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

agentpool_server/opencode_server/converters.py

@@ -2,18 +2,24 @@
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any
 import uuid
 
+import anyenv
 from pydantic_ai import (
-    TextPart as PydanticTextPart,
-    ToolCallPart as PydanticToolCallPart,
-)
-from pydantic_ai.messages import (
+    AudioUrl,
+    BinaryContent,
+    DocumentUrl,
+    ImageUrl,
     ModelRequest,
     ModelResponse,
+    RetryPromptPart,
+    TextPart as PydanticTextPart,
+    ToolCallPart as PydanticToolCallPart,
     ToolReturnPart as PydanticToolReturnPart,
     UserPromptPart,
+    VideoUrl,
 )
 
 from agentpool_server.opencode_server.models import (
@@ -37,6 +43,8 @@ from agentpool_server.opencode_server.models import (
 from agentpool_server.opencode_server.models.common import TimeCreated
 from agentpool_server.opencode_server.models.message import UserMessageModel
 from agentpool_server.opencode_server.models.parts import (
+    APIErrorInfo,
+    RetryPart,
     StepFinishPart,
     StepFinishTokens,
     StepStartPart,
@@ -49,9 +57,7 @@ from agentpool_server.opencode_server.time_utils import now_ms
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-    from pydantic_ai import (
-        UserContent,
-    )
+    from pydantic_ai import UserContent
 
     from agentpool.agents.events import (
         ToolCallCompleteEvent,
@@ -62,6 +68,8 @@ if TYPE_CHECKING:
     from agentpool_server.opencode_server.models import Part
 
 
+logger = logging.getLogger(__name__)
+
 # Parameter name mapping from snake_case to camelCase for OpenCode TUI compatibility
 _PARAM_NAME_MAP: dict[str, str] = {
     "path": "filePath",
@@ -175,6 +183,7 @@ def convert_pydantic_tool_return_part(
             title=f"Completed {part.tool_name}",
             input=existing_input,
             output=output,
+            metadata=part.metadata or {},  # Extract metadata from ToolReturnPart
             time=TimeStartEndCompacted(start=now_ms() - 1000, end=now_ms()),
         )
 
@@ -287,6 +296,7 @@ def convert_tool_complete_event(
             title=f"Completed {existing_part.tool}",
             input=existing_input,
             output=output,
+            metadata=event.metadata or {},
             time=TimeStartEndCompacted(start=now_ms() - 1000, end=now_ms()),
         )
 
@@ -320,14 +330,6 @@ def _convert_file_part_to_user_content(part: dict[str, Any]) -> Any:
     Returns:
         Appropriate pydantic-ai content type
     """
-    from pydantic_ai.messages import (
-        AudioUrl,
-        BinaryContent,
-        DocumentUrl,
-        ImageUrl,
-        VideoUrl,
-    )
-
     mime = part.get("mime", "")
     url = part.get("url", "")
 
@@ -378,6 +380,73 @@ def extract_user_prompt_from_parts(
             content = _convert_file_part_to_user_content(part)
             result.append(content)
 
+        elif part_type == "agent":
+            # Agent mention - inject instruction to delegate to sub-agent
+            # This mirrors OpenCode's server-side behavior: inject a synthetic
+            # text instruction telling the LLM to call the task tool
+            agent_name = part.get("name", "")
+            if agent_name:
+                # TODO: Implement proper agent delegation via task tool
+                # For now, we add the instruction as text that the LLM will see
+                instruction = (
+                    f"Use the above message and context to generate a prompt "
+                    f"and call the task tool with subagent: {agent_name}"
+                )
+                result.append(instruction)
+
+        elif part_type == "snapshot":
+            # File system snapshot reference
+            # TODO: Implement snapshot restoration/reference
+            snapshot_id = part.get("snapshot", "")
+            logger.debug("Ignoring snapshot part: %s", snapshot_id)
+
+        elif part_type == "patch":
+            # Diff/patch content
+            # TODO: Implement patch application
+            patch_hash = part.get("hash", "")
+            files = part.get("files", [])
+            logger.debug("Ignoring patch part: hash=%s, files=%s", patch_hash, files)
+
+        elif part_type == "reasoning":
+            # Extended thinking/reasoning content from the model
+            # Include as text context since it contains useful reasoning
+            reasoning_text = part.get("text", "")
+            if reasoning_text:
+                result.append(f"[Reasoning]: {reasoning_text}")
+
+        elif part_type == "compaction":
+            # Marks where conversation was compacted
+            # TODO: Handle compaction markers for context management
+            auto = part.get("auto", False)
+            logger.debug("Ignoring compaction part: auto=%s", auto)
+
+        elif part_type == "subtask":
+            # References a spawned subtask
+            # TODO: Implement subtask tracking/results
+            subtask_agent = part.get("agent", "")
+            subtask_desc = part.get("description", "")
+            logger.debug(
+                "Ignoring subtask part: agent=%s, description=%s", subtask_agent, subtask_desc
+            )
+
+        elif part_type == "retry":
+            # Marks a retry of a failed operation
+            # TODO: Handle retry tracking
+            attempt = part.get("attempt", 0)
+            logger.debug("Ignoring retry part: attempt=%s", attempt)
+
+        elif part_type == "step-start":
+            # Step start marker - informational only
+            logger.debug("Ignoring step-start part")
+
+        elif part_type == "step-finish":
+            # Step finish marker - informational only
+            logger.debug("Ignoring step-finish part")
+
+        else:
+            # Unknown part type
+            logger.warning("Unknown part type: %s", part_type)
+
     # If only text parts, join them as a single string for simplicity
     if all(isinstance(item, str) for item in result):
         return "\n".join(result)  # type: ignore[arg-type]
@@ -595,9 +664,52 @@ def chat_message_to_opencode(  # noqa: PLR0915
                         parts.append(tool_part)
 
             elif isinstance(model_msg, ModelRequest):
-                # Check for tool returns in requests (they come after responses)
+                # Check for tool returns and retries in requests (they come after responses)
                 for part in model_msg.parts:
-                    if isinstance(part, PydanticToolReturnPart):
+                    if isinstance(part, RetryPromptPart):
+                        # Track retry attempts - count RetryPromptParts in message history
+                        retry_count = sum(
+                            1
+                            for m in msg.messages
+                            if isinstance(m, ModelRequest)
+                            for p in m.parts
+                            if isinstance(p, RetryPromptPart)
+                        )
+
+                        # Create error info from retry content
+                        error_message = part.model_response()
+
+                        # Try to extract more info if we have structured error details
+                        is_retryable = True
+                        if isinstance(part.content, list):
+                            # Validation errors - always retryable
+                            error_type = "validation_error"
+                        elif part.tool_name:
+                            # Tool-related retry
+                            error_type = "tool_error"
+                        else:
+                            # Generic retry
+                            error_type = "retry"
+
+                        api_error = APIErrorInfo(
+                            message=error_message,
+                            status_code=None,  # Not available from pydantic-ai
+                            is_retryable=is_retryable,
+                            metadata={"error_type": error_type} if error_type else None,
+                        )
+
+                        parts.append(
+                            RetryPart(
+                                id=generate_part_id(),
+                                message_id=message_id,
+                                session_id=session_id,
+                                attempt=retry_count,
+                                error=api_error,
+                                time=TimeCreated(created=int(part.timestamp.timestamp() * 1000)),
+                            )
+                        )
+
+                    elif isinstance(part, PydanticToolReturnPart):
                         call_id = part.tool_call_id or ""
                         existing = tool_calls.get(call_id)
 
@@ -606,19 +718,13 @@ def chat_message_to_opencode(  # noqa: PLR0915
                         if isinstance(content, str):
                             output = content
                         elif isinstance(content, dict):
-                            import json
-
-                            output = json.dumps(content, indent=2)
+                            output = anyenv.dump_json(content, indent=True)
                         else:
                             output = str(content) if content is not None else ""
-
-                        # Check for error
-                        is_error = isinstance(content, dict) and "error" in content
-
                         if existing:
                             # Update existing tool part with completion
                             existing_input = _get_input_from_state(existing.state)
-                            if is_error:
+                            if isinstance(content, dict) and "error" in content:
                                 existing.state = ToolStateError(
                                     status="error",
                                     error=str(content.get("error", "Unknown error")),
@@ -636,7 +742,7 @@ def chat_message_to_opencode(  # noqa: PLR0915
                         else:
                             # Orphan return - create completed tool part
                             state: ToolStateCompleted | ToolStateError
-                            if is_error:
+                            if isinstance(content, dict) and "error" in content:
                                 state = ToolStateError(
                                     status="error",
                                     error=str(content.get("error", "Unknown error")),

agentpool_server/opencode_server/input_provider.py

@@ -14,9 +14,8 @@ from agentpool_server.opencode_server.models.events import PermissionRequestEven
 
 
 if TYPE_CHECKING:
-    from agentpool.agents.context import ConfirmationResult
+    from agentpool.agents.context import AgentContext, ConfirmationResult
     from agentpool.messaging import ChatMessage
-    from agentpool.messaging.context import NodeContext
     from agentpool.tools.base import Tool
     from agentpool_server.opencode_server.state import ServerState
 
@@ -68,7 +67,7 @@ class OpenCodeInputProvider(InputProvider):
 
     async def get_tool_confirmation(
         self,
-        context: NodeContext[Any],
+        context: AgentContext[Any],
         tool: Tool,
         args: dict[str, Any],
         message_history: list[ChatMessage[Any]] | None = None,
@@ -217,11 +216,10 @@ class OpenCodeInputProvider(InputProvider):
         self,
         params: types.ElicitRequestParams,
     ) -> types.ElicitResult | types.ErrorData:
-        """Get user response to elicitation request.
+        """Get user response to elicitation request via OpenCode questions.
 
-        For now, this returns a basic decline since OpenCode doesn't have
-        a full elicitation UI like ACP. Future versions could add support
-        for more complex elicitation flows.
+        Translates MCP elicitation requests to OpenCode question system.
+        Supports both single-select and multi-select questions.
 
         Args:
             params: MCP elicit request parameters
@@ -239,7 +237,22 @@ class OpenCodeInputProvider(InputProvider):
             # Could potentially open URL in browser here
             return types.ElicitResult(action="decline")
 
-        # For form elicitation, we don't have UI support yet
+        # For form elicitation with enum schema, use OpenCode questions
+        if isinstance(params, types.ElicitRequestFormParams):
+            schema = params.requestedSchema
+
+            # Check if schema defines options (enum)
+            enum_values = schema.get("enum")
+            if enum_values:
+                return await self._handle_question_elicitation(params, schema)
+
+            # Check if it's an array schema with enum items
+            if schema.get("type") == "array":
+                items = schema.get("items", {})
+                if items.get("enum"):
+                    return await self._handle_question_elicitation(params, schema)
+
+        # For other form elicitation, we don't have UI support yet
         logger.info(
             "Form elicitation request (not supported)",
             message=params.message,
@@ -247,12 +260,151 @@ class OpenCodeInputProvider(InputProvider):
         )
         return types.ElicitResult(action="decline")
 
+    async def _handle_question_elicitation(
+        self,
+        params: types.ElicitRequestFormParams,
+        schema: dict[str, Any],
+    ) -> types.ElicitResult | types.ErrorData:
+        """Handle elicitation via OpenCode question system.
+
+        Args:
+            params: Form elicitation parameters
+            schema: JSON schema with enum values
+
+        Returns:
+            Elicit result with user's answer
+        """
+        import asyncio
+
+        from agentpool_server.opencode_server.models.events import QuestionAskedEvent
+
+        # Extract enum values
+        is_multi = schema.get("type") == "array"
+        if is_multi:
+            enum_values = schema.get("items", {}).get("enum", [])
+        else:
+            enum_values = schema.get("enum", [])
+
+        if not enum_values:
+            return types.ElicitResult(action="decline")
+
+        # Extract descriptions if available (custom x-option-descriptions field)
+        descriptions = schema.get("x-option-descriptions", {})
+
+        # Build OpenCode question format
+        from agentpool_server.opencode_server.models.question import (
+            QuestionInfo,
+            QuestionOption,
+        )
+
+        question_id = self._generate_permission_id()  # Reuse ID generator
+        question_info = QuestionInfo(
+            question=params.message,
+            header=params.message[:12],  # Truncate to 12 chars
+            options=[
+                QuestionOption(
+                    label=str(val),
+                    description=descriptions.get(str(val), ""),
+                )
+                for val in enum_values
+            ],
+            multiple=is_multi or None,
+        )
+
+        # Create future to wait for answer
+        future: asyncio.Future[list[list[str]]] = asyncio.get_event_loop().create_future()
+
+        # Store pending question
+        from agentpool_server.opencode_server.state import PendingQuestion
+
+        self.state.pending_questions[question_id] = PendingQuestion(
+            session_id=self.session_id,
+            questions=[question_info],
+            future=future,
+            tool=None,  # Not associated with a specific tool call
+        )
+
+        # Broadcast event (serialize QuestionInfo to dict)
+        event = QuestionAskedEvent.create(
+            request_id=question_id,
+            session_id=self.session_id,
+            questions=[question_info.model_dump(mode="json", by_alias=True)],
+        )
+        await self.state.broadcast_event(event)
+
+        logger.info(
+            "Question asked",
+            question_id=question_id,
+            message=params.message,
+            is_multi=is_multi,
+        )
+
+        # Wait for answer
+        try:
+            answers = await future  # list[list[str]]
+            answer = answers[0] if answers else []  # Get first question's answer
+
+            # ElicitResult content must be a dict, not a plain value
+            # Wrap the answer in a dict with a "value" key
+            # Multi-select: return list in dict
+            # Single-select: return string in dict
+            content: dict[str, str | list[str]] = (
+                {"value": answer} if is_multi else {"value": answer[0] if answer else ""}
+            )
+            return types.ElicitResult(action="accept", content=content)
+        except asyncio.CancelledError:
+            logger.info("Question cancelled", question_id=question_id)
+            return types.ElicitResult(action="cancel")
+        except Exception as e:
+            logger.exception("Question failed", question_id=question_id)
+            return types.ErrorData(
+                code=-1,  # Generic error code
+                message=f"Elicitation failed: {e}",
+            )
+        finally:
+            # Clean up pending question
+            self.state.pending_questions.pop(question_id, None)
+
     def clear_tool_approvals(self) -> None:
         """Clear all stored tool approval decisions."""
         approval_count = len(self._tool_approvals)
         self._tool_approvals.clear()
         logger.info("Cleared tool approval decisions", count=approval_count)
 
+    def resolve_question(
+        self,
+        question_id: str,
+        answers: list[list[str]],
+    ) -> bool:
+        """Resolve a pending question request.
+
+        Called by the REST endpoint when the client responds.
+
+        Args:
+            question_id: The question request ID
+            answers: User's answers (array of arrays per OpenCode format)
+
+        Returns:
+            True if the question was found and resolved, False otherwise
+        """
+        pending = self.state.pending_questions.get(question_id)
+        if pending is None:
+            logger.warning("Question not found", question_id=question_id)
+            return False
+
+        future = pending.future
+        if future.done():
+            logger.warning("Question already resolved", question_id=question_id)
+            return False
+
+        future.set_result(answers)
+        logger.info(
+            "Question resolved",
+            question_id=question_id,
+            answers=answers,
+        )
+        return True
+
     def cancel_all_pending(self) -> int:
         """Cancel all pending permission requests.
 

agentpool_server/opencode_server/models/__init__.py

@@ -17,6 +17,7 @@ from agentpool_server.opencode_server.models.app import (
     PathInfo,
     Project,
     ProjectTime,
+    ProjectUpdateRequest,
     VcsInfo,
 )
 from agentpool_server.opencode_server.models.provider import (
@@ -37,6 +38,7 @@ from agentpool_server.opencode_server.models.session import (
     SessionRevert,
     SessionShare,
     SessionStatus,
+    SessionSummary,
     SessionUpdateRequest,
     SummarizeRequest,
     Todo,
@@ -45,8 +47,10 @@ from agentpool_server.opencode_server.models.message import (
     AssistantMessage,
     CommandRequest,
     FilePartInput,
+    MessageInfo,
     MessagePath,
     MessageRequest,
+    MessageSummary,
     MessageTime,
     MessageWithParts,
     PartInput,
@@ -55,12 +59,20 @@ from agentpool_server.opencode_server.models.message import (
     Tokens,
     TokensCache,
     UserMessage,
+    UserMessageModel,
 )
 from agentpool_server.opencode_server.models.parts import (
+    AgentPart,
+    CompactionPart,
     FilePart,
     Part,
+    PatchPart,
+    ReasoningPart,
+    RetryPart,
+    SnapshotPart,
     StepFinishPart,
     StepStartPart,
+    SubtaskPart,
     TextPart,
     TimeStart,
     TimeStartEnd,
@@ -92,10 +104,13 @@ from agentpool_server.opencode_server.models.pty import (
 )
 from agentpool_server.opencode_server.models.events import (
     Event,
+    MessageRemovedEvent,
     MessageUpdatedEvent,
     MessageUpdatedEventProperties,
+    PartRemovedEvent,
     PartUpdatedEvent,
     PartUpdatedEventProperties,
+    ProjectUpdatedEvent,
     ServerConnectedEvent,
     SessionCompactedEvent,
     SessionCompactedProperties,
@@ -112,71 +127,76 @@ from agentpool_server.opencode_server.models.events import (
     SessionStatusProperties,
     SessionUpdatedEvent,
 )
-from agentpool_server.opencode_server.models.mcp import (
-    LogRequest,
-    MCPStatus,
-)
-from agentpool_server.opencode_server.models.config import (
-    Config,
+from agentpool_server.opencode_server.models.mcp import LogRequest, MCPStatus, McpResource
+from agentpool_server.opencode_server.models.config import Config
+from agentpool_server.opencode_server.models.question import (
+    QuestionInfo,
+    QuestionOption,
+    QuestionReply,
+    QuestionRequest,
 )
 
 __all__ = [
-    # Agent
     "Agent",
-    # App
+    "AgentPart",
     "App",
     "AppTimeInfo",
-    # Message
     "AssistantMessage",
     "Command",
     "CommandRequest",
-    # Config
+    "CompactionPart",
     "Config",
-    # Events
     "Event",
-    # File
     "FileContent",
     "FileNode",
-    # Parts
     "FilePart",
     "FilePartInput",
     "FileStatus",
     "FindMatch",
     "HealthResponse",
-    # MCP
     "LogRequest",
     "MCPStatus",
+    "McpResource",
+    "MessageInfo",
     "MessagePath",
+    "MessageRemovedEvent",
     "MessageRequest",
+    "MessageSummary",
     "MessageTime",
     "MessageUpdatedEvent",
     "MessageUpdatedEventProperties",
     "MessageWithParts",
     "Mode",
     "ModeModel",
-    # Provider
     "Model",
     "ModelCost",
     "ModelLimit",
-    # Base
     "OpenCodeBaseModel",
     "Part",
     "PartInput",
+    "PartRemovedEvent",
     "PartUpdatedEvent",
     "PartUpdatedEventProperties",
+    "PatchPart",
     "PathInfo",
     "Project",
     "ProjectTime",
+    "ProjectUpdateRequest",
+    "ProjectUpdatedEvent",
     "Provider",
     "ProviderListResponse",
     "ProvidersResponse",
-    # PTY
     "PtyCreateRequest",
     "PtyInfo",
     "PtySize",
     "PtyUpdateRequest",
+    "QuestionInfo",
+    "QuestionOption",
+    "QuestionReply",
+    "QuestionRequest",
+    "ReasoningPart",
+    "RetryPart",
     "ServerConnectedEvent",
-    # Session
     "Session",
     "SessionCompactedEvent",
     "SessionCompactedProperties",
@@ -197,19 +217,20 @@ __all__ = [
     "SessionStatus",
     "SessionStatusEvent",
     "SessionStatusProperties",
+    "SessionSummary",
     "SessionUpdateRequest",
     "SessionUpdatedEvent",
     "ShellRequest",
+    "SnapshotPart",
     "StepFinishPart",
     "StepStartPart",
+    "SubtaskPart",
     "SummarizeRequest",
     "Symbol",
     "TextPart",
     "TextPartInput",
-    # Common
     "TimeCreated",
     "TimeCreatedUpdated",
-    # Time types (from parts.py)
     "TimeStart",
     "TimeStartEnd",
     "TimeStartEndCompacted",
@@ -224,5 +245,6 @@ __all__ = [
     "ToolStatePending",
     "ToolStateRunning",
     "UserMessage",
+    "UserMessageModel",
     "VcsInfo",
 ]

agentpool_server/opencode_server/models/app.py

@@ -1,5 +1,7 @@
 """App, project, and path related models."""
 
+from typing import Any
+
 from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
 
 
@@ -58,3 +60,13 @@ class VcsInfo(OpenCodeBaseModel):
     branch: str | None = None
     dirty: bool = False
     commit: str | None = None
+
+
+class ProjectUpdateRequest(OpenCodeBaseModel):
+    """Request to update project metadata."""
+
+    name: str | None = None
+    """Optional friendly name for the project."""
+
+    settings: dict[str, Any] | None = None
+    """Optional project-specific settings to update."""