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

agentpool_server/opencode_server/models/file.py

@@ -0,0 +1,88 @@
+"""File operation models."""
+
+from __future__ import annotations
+
+from typing import Literal, Self
+
+from pydantic import BaseModel, Field
+
+from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
+
+
+class FileNode(OpenCodeBaseModel):
+    """File or directory node."""
+
+    name: str
+    path: str
+    type: Literal["file", "directory"]
+    size: int | None = None
+
+
+class FileContent(OpenCodeBaseModel):
+    """File content response."""
+
+    path: str
+    content: str
+    encoding: str = "utf-8"
+
+
+class FileStatus(OpenCodeBaseModel):
+    """File status (for VCS)."""
+
+    path: str
+    status: str  # modified, added, deleted, etc.
+
+
+class TextWrapper(OpenCodeBaseModel):
+    """Wrapper for text content."""
+
+    text: str
+
+
+class SubmatchInfo(OpenCodeBaseModel):
+    """Submatch information."""
+
+    match: TextWrapper
+    start: int
+    end: int
+
+    @classmethod
+    def create(cls, text: str, start: int, end: int) -> Self:
+        return cls(match=TextWrapper(text=text), start=start, end=end)
+
+
+class FindMatch(BaseModel):
+    """Text search match."""
+
+    path: TextWrapper
+    lines: TextWrapper
+    line_number: int  # these here are snake_case in the API, so we inherit from BaseModel
+    absolute_offset: int
+    submatches: list[SubmatchInfo] = Field(default_factory=list)
+
+    @classmethod
+    def create(
+        cls,
+        path: str,
+        lines: str,
+        line_number: int,
+        absolute_offset: int,
+        submatches: list[SubmatchInfo] | None = None,
+    ) -> FindMatch:
+        return cls(
+            path=TextWrapper(text=path),
+            lines=TextWrapper(text=lines),
+            line_number=line_number,
+            absolute_offset=absolute_offset,
+            submatches=submatches or [],
+        )
+
+
+class Symbol(OpenCodeBaseModel):
+    """Code symbol."""
+
+    name: str
+    kind: str
+    path: str
+    line: int
+    character: int

agentpool_server/opencode_server/models/mcp.py

@@ -0,0 +1,44 @@
+"""MCP and logging models."""
+
+from typing import Any, Literal
+
+from pydantic import Field
+
+from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
+
+
+class LogRequest(OpenCodeBaseModel):
+    """Log entry request."""
+
+    service: str
+    level: Literal["debug", "info", "warn", "error"]
+    message: str
+    extra: dict[str, Any] | None = None
+
+
+class MCPStatus(OpenCodeBaseModel):
+    """MCP server status."""
+
+    name: str
+    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

@@ -0,0 +1,179 @@
+"""Message related models."""
+
+from __future__ import annotations
+
+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
+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."""
+
+    cwd: str
+    root: str
+
+
+class MessageTime(OpenCodeBaseModel):
+    """Time information for a message (milliseconds)."""
+
+    created: int
+    completed: int | None = None
+
+
+class TokensCache(OpenCodeBaseModel):
+    """Token cache information."""
+
+    read: int = 0
+    write: int = 0
+
+
+class Tokens(OpenCodeBaseModel):
+    """Token usage information."""
+
+    cache: TokensCache = Field(default_factory=TokensCache)
+    input: int = 0
+    output: int = 0
+    reasoning: int = 0
+
+
+class UserMessageModel(OpenCodeBaseModel):
+    """Model info for user message."""
+
+    provider_id: str
+    model_id: str
+
+
+class UserMessage(OpenCodeBaseModel):
+    """User message."""
+
+    id: str
+    role: Literal["user"] = "user"
+    session_id: str
+    time: TimeCreated
+    agent: str = "default"
+    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):
+    """Assistant message."""
+
+    id: str
+    role: Literal["assistant"] = "assistant"
+    session_id: str
+    parent_id: str  # Required - links to user message
+    model_id: str
+    provider_id: str
+    mode: str = "default"
+    agent: str = "default"
+    path: MessagePath
+    time: MessageTime
+    tokens: Tokens = Field(default_factory=Tokens)
+    cost: float = 0.0
+    error: dict[str, Any] | None = None
+    summary: bool | None = None
+    finish: str | None = None
+
+
+class MessageWithParts(OpenCodeBaseModel):
+    """Message with its parts."""
+
+    info: UserMessage | AssistantMessage
+    parts: list[Part] = Field(default_factory=list)
+
+
+# Request models
+
+
+class TextPartInput(OpenCodeBaseModel):
+    """Text part for input."""
+
+    type: Literal["text"] = "text"
+    text: str
+
+
+class FilePartSourceText(OpenCodeBaseModel):
+    """Source text info for file part."""
+
+    value: str
+    start: int
+    end: int
+
+
+class FilePartSource(OpenCodeBaseModel):
+    """Source info for file part."""
+
+    text: FilePartSourceText | None = None
+    type: str | None = None
+    path: str | None = None
+
+
+class FilePartInput(OpenCodeBaseModel):
+    """File part for input (image, document, etc.)."""
+
+    type: Literal["file"] = "file"
+    mime: str
+    filename: str | None = None
+    url: str  # Can be data: URI or file path
+    source: FilePartSource | None = None
+
+
+PartInput = TextPartInput | FilePartInput
+
+
+class MessageModelInfo(OpenCodeBaseModel):
+    """Model info in message request."""
+
+    provider_id: str
+    model_id: str
+
+
+class MessageRequest(OpenCodeBaseModel):
+    """Request body for sending a message."""
+
+    parts: list[PartInput]
+    message_id: str | None = None
+    model: MessageModelInfo | None = None
+    agent: str | None = None
+    no_reply: bool | None = None
+    system: str | None = None
+    tools: dict[str, bool] | None = None
+
+
+class ShellRequest(OpenCodeBaseModel):
+    """Request body for running a shell command."""
+
+    agent: str
+    command: str
+    model: MessageModelInfo | None = None
+
+
+class CommandRequest(OpenCodeBaseModel):
+    """Request body for executing a slash command."""
+
+    command: str
+    arguments: str | None = None
+    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

@@ -0,0 +1,323 @@
+"""Message part models."""
+
+from __future__ import annotations
+
+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):
+    """Time with only start (milliseconds).
+
+    Used by: ToolStateRunning
+    """
+
+    start: int
+
+
+class TimeStartEnd(OpenCodeBaseModel):
+    """Time with start and end, both required (milliseconds).
+
+    Used by: ToolStateError
+    """
+
+    start: int
+    end: int
+
+
+class TimeStartEndOptional(OpenCodeBaseModel):
+    """Time with start required and end optional (milliseconds).
+
+    Used by: TextPart
+    """
+
+    start: int
+    end: int | None = None
+
+
+class TimeStartEndCompacted(OpenCodeBaseModel):
+    """Time with start, end required, and optional compacted (milliseconds).
+
+    Used by: ToolStateCompleted
+    """
+
+    start: int
+    end: int
+    compacted: int | None = None
+
+
+class TextPart(OpenCodeBaseModel):
+    """Text content part."""
+
+    id: str
+    type: Literal["text"] = "text"
+    message_id: str
+    session_id: str
+    text: str
+    synthetic: bool | None = None
+    ignored: bool | None = None
+    time: TimeStartEndOptional | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class ToolStatePending(OpenCodeBaseModel):
+    """Pending tool state."""
+
+    status: Literal["pending"] = "pending"
+    input: dict[str, Any] = Field(default_factory=dict)
+    raw: str = ""
+
+
+class ToolStateRunning(OpenCodeBaseModel):
+    """Running tool state."""
+
+    status: Literal["running"] = "running"
+    time: TimeStart
+    input: dict[str, Any] = Field(default_factory=dict)
+    metadata: dict[str, Any] | None = None
+    title: str | None = None
+
+
+class ToolStateCompleted(OpenCodeBaseModel):
+    """Completed tool state."""
+
+    status: Literal["completed"] = "completed"
+    input: dict[str, Any] = Field(default_factory=dict)
+    output: str = ""
+    title: str = ""
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    time: TimeStartEndCompacted
+    attachments: list[Any] | None = None
+
+
+class ToolStateError(OpenCodeBaseModel):
+    """Error tool state."""
+
+    status: Literal["error"] = "error"
+    input: dict[str, Any] = Field(default_factory=dict)
+    error: str = ""
+    metadata: dict[str, Any] | None = None
+    time: TimeStartEnd
+
+
+ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
+
+
+class ToolPart(OpenCodeBaseModel):
+    """Tool call part."""
+
+    id: str
+    type: Literal["tool"] = "tool"
+    message_id: str
+    session_id: str
+    call_id: str
+    tool: str
+    state: ToolState
+    metadata: dict[str, Any] | None = None
+
+
+class FilePartSourceText(OpenCodeBaseModel):
+    """File part source text."""
+
+    value: str
+    start: int
+    end: int
+
+
+class FileSource(OpenCodeBaseModel):
+    """File source."""
+
+    text: FilePartSourceText
+    type: Literal["file"] = "file"
+    path: str
+
+
+class FilePart(OpenCodeBaseModel):
+    """File content part."""
+
+    id: str
+    type: Literal["file"] = "file"
+    message_id: str
+    session_id: str
+    mime: str
+    filename: str | None = None
+    url: str
+    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."""
+
+    id: str
+    type: Literal["step-start"] = "step-start"
+    message_id: str
+    session_id: str
+    snapshot: str | None = None
+
+
+class TokenCache(OpenCodeBaseModel):
+    """Token cache information."""
+
+    read: int = 0
+    write: int = 0
+
+
+class StepFinishTokens(OpenCodeBaseModel):
+    """Token usage for step finish."""
+
+    input: int = 0
+    output: int = 0
+    reasoning: int = 0
+    cache: TokenCache = Field(default_factory=TokenCache)
+
+
+class StepFinishPart(OpenCodeBaseModel):
+    """Step finish marker."""
+
+    id: str
+    type: Literal["step-finish"] = "step-finish"
+    message_id: str
+    session_id: str
+    reason: str = "stop"
+    snapshot: str | None = None
+    cost: float = 0.0
+    tokens: StepFinishTokens = Field(default_factory=StepFinishTokens)
+
+
+Part = (
+    TextPart
+    | ToolPart
+    | FilePart
+    | AgentPart
+    | SnapshotPart
+    | PatchPart
+    | ReasoningPart
+    | CompactionPart
+    | SubtaskPart
+    | RetryPart
+    | StepStartPart
+    | StepFinishPart
+)

agentpool_server/opencode_server/models/provider.py

@@ -0,0 +1,81 @@
+"""Provider, model, and mode related models."""
+
+from typing import Any
+
+from pydantic import Field
+
+from agentpool_server.opencode_server.models.base import OpenCodeBaseModel
+
+
+class ModelCost(OpenCodeBaseModel):
+    """Cost information for a model."""
+
+    input: float
+    output: float
+    cache_read: float | None = None
+    cache_write: float | None = None
+
+
+class ModelLimit(OpenCodeBaseModel):
+    """Limit information for a model."""
+
+    context: float
+    output: float
+
+
+class Model(OpenCodeBaseModel):
+    """Model information."""
+
+    id: str
+    name: str
+    attachment: bool = False
+    cost: ModelCost
+    limit: ModelLimit
+    options: dict[str, Any] = Field(default_factory=dict)
+    reasoning: bool = False
+    release_date: str = ""
+    temperature: bool = True
+    tool_call: bool = True
+
+
+class Provider(OpenCodeBaseModel):
+    """Provider information."""
+
+    id: str
+    name: str
+    env: list[str] = Field(default_factory=list)
+    models: dict[str, Model] = Field(default_factory=dict)
+    api: str | None = None
+    npm: str | None = None
+
+
+class ProvidersResponse(OpenCodeBaseModel):
+    """Response for /config/providers endpoint."""
+
+    providers: list[Provider]
+    default: dict[str, str] = Field(default_factory=dict)
+
+
+class ProviderListResponse(OpenCodeBaseModel):
+    """Response for /provider endpoint."""
+
+    all: list[Provider]
+    default: dict[str, str] = Field(default_factory=dict)
+    connected: list[str] = Field(default_factory=list)
+
+
+class ModeModel(OpenCodeBaseModel):
+    """Model selection for a mode."""
+
+    model_id: str
+    provider_id: str
+
+
+class Mode(OpenCodeBaseModel):
+    """Agent mode configuration."""
+
+    name: str
+    tools: dict[str, bool] = Field(default_factory=dict)
+    model: ModeModel | None = None
+    prompt: str | None = None
+    temperature: float | None = None