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

agentpool_server/opencode_server/models/events.py

@@ -6,6 +6,7 @@ from typing import Any, Literal, Self
 
 from pydantic import Field
 
+from agentpool_server.opencode_server.models.app import Project  # noqa: TC001
 from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
 from agentpool_server.opencode_server.models.message import (  # noqa: TC001
     AssistantMessage,
@@ -203,26 +204,68 @@ class PartUpdatedEvent(OpenCodeBaseModel):
         return cls(properties=PartUpdatedEventProperties(part=part, delta=delta))
 
 
-class PermissionTimeInfo(OpenCodeBaseModel):
-    """Time information for permission event."""
+class MessageRemovedProperties(OpenCodeBaseModel):
+    """Properties for message removed event."""
 
-    created: int
+    session_id: str = Field(alias="sessionID")
+    message_id: str = Field(alias="messageID")
 
 
-class PermissionUpdatedProperties(OpenCodeBaseModel):
-    """Properties for permission updated event.
+class MessageRemovedEvent(OpenCodeBaseModel):
+    """Message removed event - emitted during revert."""
 
-    Matches OpenCode's Permission.Info schema.
-    """
+    type: Literal["message.removed"] = "message.removed"
+    properties: MessageRemovedProperties
 
-    id: str
-    """Permission ID."""
+    @classmethod
+    def create(cls, session_id: str, message_id: str) -> Self:
+        """Create message removed event.
 
-    type: str
-    """Tool type/name."""
+        Args:
+            session_id: Session identifier
+            message_id: Message identifier
 
-    session_id: str
-    """Session ID."""
+        Returns:
+            MessageRemovedEvent instance
+        """
+        return cls(properties=MessageRemovedProperties(sessionID=session_id, messageID=message_id))
+
+
+class PartRemovedProperties(OpenCodeBaseModel):
+    """Properties for part removed event."""
+
+    session_id: str = Field(alias="sessionID")
+    message_id: str = Field(alias="messageID")
+    part_id: str = Field(alias="partID")
+
+
+class PartRemovedEvent(OpenCodeBaseModel):
+    """Part removed event - emitted during revert."""
+
+    type: Literal["message.part.removed"] = "message.part.removed"
+    properties: PartRemovedProperties
+
+    @classmethod
+    def create(cls, session_id: str, message_id: str, part_id: str) -> Self:
+        """Create part removed event.
+
+        Args:
+            session_id: Session identifier
+            message_id: Message identifier
+            part_id: Part identifier
+
+        Returns:
+            PartRemovedEvent instance
+        """
+        return cls(
+            properties=PartRemovedProperties(
+                sessionID=session_id, messageID=message_id, partID=part_id
+            )
+        )
+
+
+class PermissionToolInfo(OpenCodeBaseModel):
+    """Tool information for permission event."""
 
     message_id: str
     """Message ID."""
@@ -230,27 +273,43 @@ class PermissionUpdatedProperties(OpenCodeBaseModel):
     call_id: str | None = None
     """Optional tool call ID."""
 
-    title: str
-    """Human-readable title for the permission request."""
+
+class PermissionAskedProperties(OpenCodeBaseModel):
+    """Properties for permission.asked event.
+
+    Matches OpenCode's PermissionNext.Event.Asked schema.
+    """
+
+    id: str
+    """Permission request ID."""
+
+    session_id: str
+    """Session ID."""
+
+    permission: str
+    """Tool/permission type name."""
+
+    patterns: list[str]
+    """Patterns for matching (e.g., file paths, commands)."""
 
     metadata: dict[str, Any]
     """Arbitrary metadata about the tool call."""
 
-    time: PermissionTimeInfo
-    """Timestamp information."""
+    always: list[str]
+    """Patterns that would be approved for future requests if user selects 'always'."""
 
-    pattern: str | list[str] | None = None
-    """Optional pattern for matching."""
+    tool: PermissionToolInfo
+    """Tool call information."""
 
 
 class PermissionRequestEvent(OpenCodeBaseModel):
     """Permission request event - sent when a tool needs user confirmation.
 
-    Uses 'permission.updated' event type for OpenCode TUI compatibility.
+    Uses 'permission.asked' event type for OpenCode TUI compatibility.
     """
 
-    type: Literal["permission.updated"] = "permission.updated"
-    properties: PermissionUpdatedProperties
+    type: Literal["permission.asked"] = "permission.asked"
+    properties: PermissionAskedProperties
 
     @classmethod
     def create(
@@ -263,17 +322,17 @@ class PermissionRequestEvent(OpenCodeBaseModel):
         message_id: str = "",
         call_id: str | None = None,
     ) -> Self:
-        import time
+        # Create pattern from tool name and args
+        pattern = f"{tool_name}: {args_preview}" if args_preview else tool_name
 
-        props = PermissionUpdatedProperties(
+        props = PermissionAskedProperties(
             id=permission_id,
-            type=tool_name,
             session_id=session_id,
-            message_id=message_id,
-            call_id=call_id,
-            title=message,
+            permission=tool_name,
+            patterns=[pattern],
             metadata={"args_preview": args_preview},
-            time=PermissionTimeInfo(created=int(time.time() * 1000)),
+            always=[pattern],  # Same pattern for "always" approval
+            tool=PermissionToolInfo(message_id=message_id, call_id=call_id),
         )
         return cls(properties=props)
 
@@ -601,6 +660,25 @@ class LspClientDiagnosticsEvent(OpenCodeBaseModel):
 # =============================================================================
 
 
+class ProjectUpdatedEvent(OpenCodeBaseModel):
+    """Project metadata updated event."""
+
+    type: Literal["project.updated"] = "project.updated"
+    properties: Project
+
+    @classmethod
+    def create(cls, project: Project) -> Self:
+        """Create project updated event.
+
+        Args:
+            project: The updated project data
+
+        Returns:
+            ProjectUpdatedEvent instance
+        """
+        return cls(properties=project)
+
+
 class VcsBranchUpdatedProperties(OpenCodeBaseModel):
     """Properties for VCS branch updated event."""
 
@@ -619,6 +697,96 @@ class VcsBranchUpdatedEvent(OpenCodeBaseModel):
         return cls(properties=VcsBranchUpdatedProperties(branch=branch))
 
 
+class QuestionAskedProperties(OpenCodeBaseModel):
+    """Properties for question asked event."""
+
+    id: str
+    session_id: str
+    questions: list[dict[str, Any]]
+    tool: dict[str, str] | None = None
+
+
+class QuestionAskedEvent(OpenCodeBaseModel):
+    """Question asked event - sent when agent asks a question."""
+
+    type: Literal["question.asked"] = "question.asked"
+    properties: QuestionAskedProperties
+
+    @classmethod
+    def create(
+        cls,
+        request_id: str,
+        session_id: str,
+        questions: list[dict[str, Any]],
+        tool: dict[str, str] | None = None,
+    ) -> Self:
+        return cls(
+            properties=QuestionAskedProperties(
+                id=request_id,
+                sessionID=session_id,
+                questions=questions,
+                tool=tool,
+            )
+        )
+
+
+class QuestionRepliedProperties(OpenCodeBaseModel):
+    """Properties for question replied event."""
+
+    session_id: str
+    request_id: str
+    answers: list[list[str]]
+
+
+class QuestionRepliedEvent(OpenCodeBaseModel):
+    """Question replied event - sent when user answers a question."""
+
+    type: Literal["question.replied"] = "question.replied"
+    properties: QuestionRepliedProperties
+
+    @classmethod
+    def create(
+        cls,
+        session_id: str,
+        request_id: str,
+        answers: list[list[str]],
+    ) -> Self:
+        return cls(
+            properties=QuestionRepliedProperties(
+                sessionID=session_id,
+                requestID=request_id,
+                answers=answers,
+            )
+        )
+
+
+class QuestionRejectedProperties(OpenCodeBaseModel):
+    """Properties for question rejected event."""
+
+    session_id: str
+    request_id: str
+
+
+class QuestionRejectedEvent(OpenCodeBaseModel):
+    """Question rejected event - sent when user dismisses a question."""
+
+    type: Literal["question.rejected"] = "question.rejected"
+    properties: QuestionRejectedProperties
+
+    @classmethod
+    def create(
+        cls,
+        session_id: str,
+        request_id: str,
+    ) -> Self:
+        return cls(
+            properties=QuestionRejectedProperties(
+                sessionID=session_id,
+                requestID=request_id,
+            )
+        )
+
+
 Event = (
     ServerConnectedEvent
     | SessionCreatedEvent
@@ -628,9 +796,14 @@ Event = (
     | SessionErrorEvent
     | SessionIdleEvent
     | MessageUpdatedEvent
+    | MessageRemovedEvent
     | PartUpdatedEvent
+    | PartRemovedEvent
     | PermissionRequestEvent
     | PermissionResolvedEvent
+    | QuestionAskedEvent
+    | QuestionRepliedEvent
+    | QuestionRejectedEvent
     | TodoUpdatedEvent
     | FileWatcherUpdatedEvent
     | SessionCompactedEvent
@@ -640,6 +813,7 @@ Event = (
     | PtyDeletedEvent
     | LspUpdatedEvent
     | LspClientDiagnosticsEvent
+    | ProjectUpdatedEvent
     | VcsBranchUpdatedEvent
     | TuiPromptAppendEvent
     | TuiCommandExecuteEvent

agentpool_server/opencode_server/models/mcp.py

@@ -23,3 +23,22 @@ class MCPStatus(OpenCodeBaseModel):
     status: Literal["connected", "disconnected", "error"]
     tools: list[str] = Field(default_factory=list)
     error: str | None = None
+
+
+class McpResource(OpenCodeBaseModel):
+    """MCP resource info matching OpenCode SDK McpResource type."""
+
+    name: str
+    """Name of the resource."""
+
+    uri: str
+    """URI identifying the resource location."""
+
+    description: str | None = None
+    """Optional description of the resource."""
+
+    mime_type: str | None = None
+    """MIME type of the resource content."""
+
+    client: str
+    """Name of the MCP client/server providing this resource."""

agentpool_server/opencode_server/models/message.py

@@ -11,6 +11,14 @@ from agentpool_server.opencode_server.models.common import TimeCreated  # noqa:
 from agentpool_server.opencode_server.models.parts import Part  # noqa: TC001
 
 
+class MessageSummary(OpenCodeBaseModel):
+    """Summary information for a message."""
+
+    title: str | None = None
+    body: str | None = None
+    diffs: list[Any] = Field(default_factory=list)
+
+
 class MessagePath(OpenCodeBaseModel):
     """Path context for a message."""
 
@@ -56,7 +64,11 @@ class UserMessage(OpenCodeBaseModel):
     session_id: str
     time: TimeCreated
     agent: str = "default"
-    model: UserMessageModel
+    model: UserMessageModel | None = None
+    summary: MessageSummary | None = None
+    system: str | None = None
+    tools: dict[str, bool] | None = None
+    variant: str | None = None
 
 
 class AssistantMessage(OpenCodeBaseModel):
@@ -160,3 +172,8 @@ class CommandRequest(OpenCodeBaseModel):
     agent: str | None = None
     model: str | None = None  # Format: "providerID/modelID"
     message_id: str | None = None
+
+
+# Type unions
+
+MessageInfo = UserMessage | AssistantMessage

agentpool_server/opencode_server/models/parts.py

@@ -7,6 +7,7 @@ from typing import Any, Literal
 from pydantic import Field
 
 from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
+from agentpool_server.opencode_server.models.common import TimeCreated  # noqa: TC001
 
 
 class TimeStart(OpenCodeBaseModel):
@@ -148,6 +149,125 @@ class FilePart(OpenCodeBaseModel):
     source: FileSource | None = None
 
 
+class AgentPartSource(OpenCodeBaseModel):
+    """Agent part source location in original text."""
+
+    value: str
+    start: int
+    end: int
+
+
+class AgentPart(OpenCodeBaseModel):
+    """Agent mention part - references a sub-agent to delegate to.
+
+    When a user types @agent-name in the prompt, this part is created.
+    The server should inject a synthetic instruction to call the task tool
+    with the specified agent.
+    """
+
+    id: str
+    type: Literal["agent"] = "agent"
+    message_id: str
+    session_id: str
+    name: str
+    """Name of the agent to delegate to."""
+    source: AgentPartSource | None = None
+    """Source location in the original prompt text."""
+
+
+class SnapshotPart(OpenCodeBaseModel):
+    """File system snapshot reference."""
+
+    id: str
+    type: Literal["snapshot"] = "snapshot"
+    message_id: str
+    session_id: str
+    snapshot: str
+    """Snapshot identifier."""
+
+
+class PatchPart(OpenCodeBaseModel):
+    """Diff/patch content part."""
+
+    id: str
+    type: Literal["patch"] = "patch"
+    message_id: str
+    session_id: str
+    hash: str
+    """Hash of the patch."""
+    files: list[str] = Field(default_factory=list)
+    """List of files affected by this patch."""
+
+
+class ReasoningPart(OpenCodeBaseModel):
+    """Extended thinking/reasoning content part.
+
+    Used for models that support extended thinking (e.g., Claude with thinking tokens).
+    """
+
+    id: str
+    type: Literal["reasoning"] = "reasoning"
+    message_id: str
+    session_id: str
+    text: str
+    """The reasoning/thinking content."""
+    metadata: dict[str, Any] | None = None
+    time: TimeStartEndOptional | None = None
+
+
+class CompactionPart(OpenCodeBaseModel):
+    """Marks where conversation was compacted/summarized."""
+
+    id: str
+    type: Literal["compaction"] = "compaction"
+    message_id: str
+    session_id: str
+    auto: bool = False
+    """Whether this was an automatic compaction."""
+
+
+class SubtaskPart(OpenCodeBaseModel):
+    """References a spawned subtask."""
+
+    id: str
+    type: Literal["subtask"] = "subtask"
+    message_id: str
+    session_id: str
+    prompt: str
+    """The prompt for the subtask."""
+    description: str
+    """Description of what the subtask does."""
+    agent: str
+    """The agent handling this subtask."""
+    command: str | None = None
+    """Optional command associated with the subtask."""
+
+
+class APIErrorInfo(OpenCodeBaseModel):
+    """API error information for retry parts."""
+
+    message: str
+    status_code: int | None = None
+    is_retryable: bool = False
+    response_headers: dict[str, str] | None = None
+    response_body: str | None = None
+    metadata: dict[str, str] | None = None
+
+
+class RetryPart(OpenCodeBaseModel):
+    """Marks a retry of a failed operation."""
+
+    id: str
+    type: Literal["retry"] = "retry"
+    message_id: str
+    session_id: str
+    attempt: int
+    """Which retry attempt this is."""
+    error: APIErrorInfo
+    """Error information from the failed attempt."""
+    time: TimeCreated
+
+
 class StepStartPart(OpenCodeBaseModel):
     """Step start marker."""
 
@@ -187,4 +307,17 @@ class StepFinishPart(OpenCodeBaseModel):
     tokens: StepFinishTokens = Field(default_factory=StepFinishTokens)
 
 
-Part = TextPart | ToolPart | FilePart | StepStartPart | StepFinishPart
+Part = (
+    TextPart
+    | ToolPart
+    | FilePart
+    | AgentPart
+    | SnapshotPart
+    | PatchPart
+    | ReasoningPart
+    | CompactionPart
+    | SubtaskPart
+    | RetryPart
+    | StepStartPart
+    | StepFinishPart
+)

agentpool_server/opencode_server/models/question.py

@@ -0,0 +1,56 @@
+"""Question models for OpenCode compatibility."""
+
+from __future__ import annotations
+
+from pydantic import Field
+
+from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
+
+
+class QuestionOption(OpenCodeBaseModel):
+    """A single option for a question."""
+
+    label: str
+    """Display text (1-5 words, concise)."""
+
+    description: str
+    """Explanation of choice."""
+
+
+class QuestionInfo(OpenCodeBaseModel):
+    """Information about a single question."""
+
+    question: str
+    """Complete question."""
+
+    header: str = Field(max_length=12)
+    """Very short label (max 12 chars)."""
+
+    options: list[QuestionOption]
+    """Available choices."""
+
+    multiple: bool | None = None
+    """Allow selecting multiple choices."""
+
+
+class QuestionRequest(OpenCodeBaseModel):
+    """A pending question request."""
+
+    id: str
+    """Unique question identifier."""
+
+    session_id: str
+    """Session identifier."""
+
+    questions: list[QuestionInfo]
+    """List of questions to ask."""
+
+    tool: dict[str, str] | None = None
+    """Optional tool context: {message_id, call_id}."""
+
+
+class QuestionReply(OpenCodeBaseModel):
+    """Reply to a question request."""
+
+    answers: list[list[str]]
+    """User answers in order of questions (each answer is an array of selected labels)."""

agentpool_server/opencode_server/models/session.py

@@ -2,12 +2,23 @@
 
 from __future__ import annotations
 
-from typing import Literal
+from typing import Any, Literal
+
+from pydantic import Field
 
 from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
 from agentpool_server.opencode_server.models.common import TimeCreatedUpdated  # noqa: TC001
 
 
+class SessionSummary(OpenCodeBaseModel):
+    """Summary information for a session."""
+
+    additions: int | None = None
+    deletions: int | None = None
+    files: int | None = None
+    diffs: list[Any] = Field(default_factory=list)
+
+
 class SessionRevert(OpenCodeBaseModel):
     """Revert information for a session."""
 
@@ -33,6 +44,7 @@ class Session(OpenCodeBaseModel):
     version: str = "1"
     time: TimeCreatedUpdated
     parent_id: str | None = None
+    summary: SessionSummary | None = None
     revert: SessionRevert | None = None
     share: SessionShare | None = None
 

agentpool_server/opencode_server/routes/__init__.py

@@ -7,6 +7,8 @@ from agentpool_server.opencode_server.routes.session_routes import router as ses
 from agentpool_server.opencode_server.routes.message_routes import router as message_router
 from agentpool_server.opencode_server.routes.file_routes import router as file_router
 from agentpool_server.opencode_server.routes.agent_routes import router as agent_router
+from agentpool_server.opencode_server.routes.permission_routes import router as permission_router
+from agentpool_server.opencode_server.routes.question_routes import router as question_router
 from agentpool_server.opencode_server.routes.pty_routes import router as pty_router
 from agentpool_server.opencode_server.routes.tui_routes import router as tui_router
 from agentpool_server.opencode_server.routes.lsp_routes import router as lsp_router
@@ -19,7 +21,9 @@ __all__ = [
     "global_router",
     "lsp_router",
     "message_router",
+    "permission_router",
     "pty_router",
+    "question_router",
     "session_router",
     "tui_router",
 ]

agentpool_server/opencode_server/routes/agent_routes.py

@@ -21,11 +21,12 @@ from agentpool_config.mcp_server import (
     StdioMCPServerConfig,
     StreamableHTTPMCPServerConfig,
 )
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
-from agentpool_server.opencode_server.models import (  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models import (
     Agent,
     Command,
     LogRequest,
+    McpResource,
     MCPStatus,
 )
 
@@ -178,6 +179,36 @@ async def log(request: LogRequest, state: StateDep) -> bool:
     return True
 
 
+@router.get("/experimental/resource")
+async def list_mcp_resources(state: StateDep) -> dict[str, McpResource]:
+    """Get all available MCP resources from connected servers.
+
+    Returns a dictionary mapping resource keys to McpResource objects.
+    Keys are formatted as "{client}:{resource_name}" for uniqueness.
+    """
+    try:
+        resources = await state.agent.tools.list_resources()
+        result: dict[str, McpResource] = {}
+
+        for resource in resources:
+            # Create unique key: sanitize client and resource names
+            client_name = (resource.client or "unknown").replace("/", "_")
+            resource_name = resource.name.replace("/", "_")
+            key = f"{client_name}:{resource_name}"
+
+            result[key] = McpResource(
+                name=resource.name,
+                uri=resource.uri,
+                description=resource.description,
+                mime_type=resource.mime_type,
+                client=resource.client or "unknown",
+            )
+    except Exception:  # noqa: BLE001
+        return {}
+    else:
+        return result
+
+
 @router.get("/experimental/tool/ids")
 async def list_tool_ids(state: StateDep) -> list[str]:
     """List all available tool IDs.