agentpool 2.1.9__py3-none-any.whl

agentpool_server/openai_api_server/completions/models.py

@@ -0,0 +1,98 @@
+"""OpenAI-compatible API server for AgentPool."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+from pydantic import Field
+from schemez import Schema
+
+from agentpool.log import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class CompletionUsage(TypedDict):
+    """Token usage information."""
+
+    input_tokens: int
+    output_tokens: int
+    total_tokens: int
+
+
+class OpenAIModelInfo(Schema):
+    """OpenAI model info format."""
+
+    id: str
+    object: str = "model"
+    owned_by: str = "agentpool"
+    created: int
+    description: str | None = None
+    permissions: list[str] = Field(default_factory=list)
+
+
+class FunctionCall(Schema):
+    """Function call information."""
+
+    name: str
+    arguments: str
+
+
+class ToolCall(Schema):
+    """Tool call information."""
+
+    id: str
+    type: str = "function"
+    function: FunctionCall
+
+
+class OpenAIMessage(Schema):
+    """OpenAI chat message format."""
+
+    role: Literal["system", "user", "assistant", "tool", "function"]
+    content: str | None  # Content can be null in function calls
+    name: str | None = None
+    function_call: FunctionCall | None = None
+    tool_calls: list[ToolCall] | None = None
+
+
+class ChatCompletionRequest(Schema):
+    """OpenAI chat completion request."""
+
+    model: str
+    messages: list[OpenAIMessage]
+    stream: bool = False
+    temperature: float | None = None
+    max_tokens: int | None = None
+    tools: list[dict[str, Any]] | None = None
+    tool_choice: str | None = Field(default="auto")
+
+
+class Choice(Schema):
+    """Choice in a completion response."""
+
+    index: int = 0
+    message: OpenAIMessage
+    finish_reason: str = "stop"
+
+
+class ChatCompletionResponse(Schema):
+    """OpenAI chat completion response."""
+
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: list[Choice]
+    usage: CompletionUsage | None = None
+
+
+class ChatCompletionChunk(Schema):
+    """Chunk of a streaming chat completion."""
+
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: list[dict[str, Any]]

agentpool_server/openai_api_server/responses/__init__.py

@@ -0,0 +1 @@
+"""Responses API."""

agentpool_server/openai_api_server/responses/helpers.py

@@ -0,0 +1,74 @@
+"""OpenAI-compatible responses endpoint."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from agentpool_server.openai_api_server.responses.models import (
+    Response,
+    ResponseMessage,
+    ResponseOutputText,
+    ResponseToolCall,
+    ResponseUsage,
+)
+
+
+if TYPE_CHECKING:
+    from agentpool.agents import Agent
+    from agentpool.agents.acp_agent import ACPAgent
+    from agentpool_server.openai_api_server.responses.models import ResponseRequest
+
+
+async def handle_request(request: ResponseRequest, agent: Agent[Any, Any] | ACPAgent) -> Response:
+    from fastapi import HTTPException
+
+    match request.input:
+        case str():
+            content = request.input
+        case list():
+            # Get last text content from structured input
+            last = request.input[-1]["content"]
+            text_parts = [p["text"] for p in last if p["type"] == "input_text"]
+            content = "\n".join(text_parts)
+        case _:
+            raise HTTPException(400, "Invalid input format")
+
+    message = await agent.run(content)
+    text = ResponseOutputText(text=str(message.content))
+    output_msg_id = f"msg_{uuid4().hex}"
+    output_msg = ResponseMessage(id=output_msg_id, role="assistant", content=[text])
+    output: list[ResponseMessage | ResponseToolCall] = [output_msg]
+
+    calls = [
+        ResponseToolCall(type=f"{tc.tool_name}_call", id=tc.tool_call_id)
+        for tc in message.get_tool_calls()
+    ]
+    output = calls + output  # type: ignore
+
+    usage_info: ResponseUsage | None = None
+    if message.cost_info and (token_usage := message.cost_info.token_usage):
+        # Map the keys correctly from agent's dict to ResponseUsage TypedDict
+        input_tk = token_usage.input_tokens
+        output_tk = token_usage.output_tokens
+        total_tk = token_usage.total_tokens
+
+        usage_info = ResponseUsage(
+            input_tokens=input_tk,
+            input_tokens_details={},
+            output_tokens=output_tk,
+            output_tokens_details={},
+            total_tokens=total_tk,
+        )
+
+    return Response(
+        model=request.model,
+        output=output,
+        instructions=request.instructions,
+        max_output_tokens=request.max_output_tokens,
+        temperature=request.temperature,
+        tools=request.tools,
+        tool_choice=request.tool_choice,
+        usage=usage_info,
+        metadata=request.metadata,
+    )

agentpool_server/openai_api_server/responses/models.py

@@ -0,0 +1,96 @@
+"""Models for OpenAI responses endpoint."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import datetime
+from typing import Any, Literal, TypedDict
+from uuid import uuid4
+
+from pydantic import Field
+from schemez import Schema
+
+
+class InputText(Schema):
+    """Text input part."""
+
+    type: Literal["input_text"] = "input_text"
+    text: str
+
+
+class InputImage(Schema):
+    """Image input part."""
+
+    type: Literal["input_image"] = "input_image"
+    image_url: str
+
+
+class ResponseOutputText(Schema):
+    """Text output part."""
+
+    type: Literal["output_text"] = "output_text"
+    text: str
+    annotations: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class ResponseToolCall(Schema):
+    """Tool call in response."""
+
+    type: str  # web_search_call etc
+    id: str
+    status: Literal["completed", "error"] = "completed"
+
+
+class ResponseMessage(Schema):
+    """ResponseMessage in response."""
+
+    type: Literal["message"] = "message"
+    id: str
+    status: Literal["completed", "error"] = "completed"
+    role: Literal["user", "assistant", "system"]
+    content: list[ResponseOutputText]
+
+
+class ResponseUsage(TypedDict):
+    """Token usage information."""
+
+    input_tokens: int
+    input_tokens_details: dict[str, int]
+    output_tokens: int
+    output_tokens_details: dict[str, int]
+    total_tokens: int
+
+
+class ResponseRequest(Schema):
+    """Request for /v1/responses endpoint."""
+
+    model: str
+    input: str | list[dict[str, Any]]
+    instructions: str | None = None
+    stream: bool = False
+    temperature: float = 1.0
+    tools: list[dict[str, Any]] = Field(default_factory=list)
+    tool_choice: str = "auto"
+    max_output_tokens: int | None = None
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+
+class Response(Schema):
+    """Response from /v1/responses endpoint."""
+
+    id: str = Field(default_factory=lambda: f"resp_{uuid4().hex}")
+    object: Literal["response"] = "response"
+    created_at: int = Field(default_factory=lambda: int(datetime.now().timestamp()))
+    status: Literal["completed", "error"] = "completed"
+    error: str | None = None
+    model: str
+    output: Sequence[ResponseMessage | ResponseToolCall]
+
+    # Include all the request parameters
+    instructions: str | None = None
+    max_output_tokens: int | None = None
+    temperature: float = 1.0
+    tools: list[dict[str, Any]] = Field(default_factory=list)
+    tool_choice: str = "auto"
+    usage: ResponseUsage | None = None
+    metadata: dict[str, str] = Field(default_factory=dict)

agentpool_server/openai_api_server/server.py

@@ -0,0 +1,242 @@
+"""OpenAI-compatible API server for AgentPool."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any
+
+import anyenv
+
+from agentpool.log import get_logger
+from agentpool_server import BaseServer
+from agentpool_server.openai_api_server.completions.helpers import stream_response
+from agentpool_server.openai_api_server.completions.models import (
+    ChatCompletionResponse,
+    Choice,
+    OpenAIMessage,
+    OpenAIModelInfo,
+)
+from agentpool_server.openai_api_server.responses.helpers import handle_request
+
+
+if TYPE_CHECKING:
+    from fastapi import Header, Response
+
+    from agentpool import AgentPool
+    from agentpool_server.openai_api_server.completions.models import ChatCompletionRequest
+    from agentpool_server.openai_api_server.responses.models import (
+        Response as ResponsesResponse,
+        ResponseRequest,
+    )
+logger = get_logger(__name__)
+
+
+class OpenAIAPIServer(BaseServer):
+    """OpenAI-compatible API server backed by AgentPool.
+
+    Provides both chat completions and responses endpoints.
+    """
+
+    def __init__(
+        self,
+        pool: AgentPool,
+        *,
+        name: str | None = None,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        cors: bool = True,
+        docs: bool = True,
+        api_key: str | None = None,
+        raise_exceptions: bool = False,
+    ) -> None:
+        """Initialize OpenAI-compatible server.
+
+        Args:
+            pool: AgentPool containing available agents
+            name: Optional Server name (auto-generated if None)
+            host: Host to bind server to
+            port: Port to bind server to
+            cors: Whether to enable CORS middleware
+            docs: Whether to enable API documentation endpoints
+            api_key: Optional API key for authentication
+            raise_exceptions: Whether to raise exceptions during server start
+        """
+        from fastapi import Depends, FastAPI
+        import logfire
+
+        super().__init__(pool, name=name, raise_exceptions=raise_exceptions)
+        self.host = host
+        self.port = port
+        self.api_key = api_key
+        self.app = FastAPI()
+        logfire.instrument_fastapi(self.app)
+
+        if cors:
+            from fastapi.middleware.cors import CORSMiddleware
+
+            self.app.add_middleware(
+                CORSMiddleware,
+                allow_origins=["*"],
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
+            )
+
+        if not docs:
+            self.app.docs_url = None
+            self.app.redoc_url = None
+
+        # Add routes with authentication dependency
+        dep = Depends(self.verify_api_key)
+        self.app.get("/v1/models")(self.list_models)
+        self.app.post("/v1/chat/completions", dependencies=[dep], response_model=None)(
+            self.create_chat_completion
+        )
+        self.app.post("/v1/responses", dependencies=[dep])(self.create_response)
+
+    def verify_api_key(
+        self, authorization: Annotated[str | None, Header(alias="Authorization")] = None
+    ) -> None:
+        """Verify API key if configured."""
+        from fastapi import HTTPException
+
+        if not authorization:
+            raise HTTPException(401, "Missing API key")
+        if not authorization.startswith("Bearer "):
+            raise HTTPException(401, "Invalid authorization format")
+        if self.api_key and authorization != f"Bearer {self.api_key}":
+            raise HTTPException(401, "Invalid API key")
+
+    async def list_models(self) -> dict[str, Any]:
+        """List available agents as models."""
+        models = []
+        for name, agent in self.pool.all_agents.items():
+            info = OpenAIModelInfo(id=name, created=0, description=agent.description)
+            models.append(info)
+        return {"object": "list", "data": models}
+
+    async def create_chat_completion(self, request: ChatCompletionRequest) -> Response:
+        """Handle chat completion requests."""
+        from fastapi import HTTPException, Response
+        from fastapi.responses import StreamingResponse
+
+        try:
+            agent = self.pool.all_agents[request.model]
+        except KeyError:
+            raise HTTPException(404, f"Model {request.model} not found") from None
+
+        # Just take the last message content - let agent handle history
+        content = request.messages[-1].content or ""
+        if request.stream:
+            return StreamingResponse(
+                stream_response(agent, content, request),
+                media_type="text/event-stream",
+            )
+        try:
+            response = await agent.run(content)
+            message = OpenAIMessage(role="assistant", content=str(response.content))
+            completion_response = ChatCompletionResponse(
+                id=response.message_id,
+                created=int(response.timestamp.timestamp()),
+                model=request.model,
+                choices=[Choice(message=message)],
+                usage=response.cost_info.token_usage if response.cost_info else None,  # pyright: ignore
+            )
+            json = completion_response.model_dump_json()
+            return Response(content=json, media_type="application/json")
+        except Exception as e:
+            self.log.exception("Error processing chat completion")
+            raise HTTPException(500, f"Error: {e!s}") from e
+
+    async def create_response(self, req_body: ResponseRequest) -> ResponsesResponse:
+        """Handle response creation requests."""
+        from fastapi import HTTPException
+
+        try:
+            agent = self.pool.agents[req_body.model]
+            return await handle_request(req_body, agent)
+        except KeyError:
+            raise HTTPException(404, f"Model {req_body.model} not found") from None
+        except Exception as e:
+            raise HTTPException(500, str(e)) from e
+
+    async def _start_async(self) -> None:
+        """Start the server (blocking async - runs until stopped)."""
+        import uvicorn
+
+        config = uvicorn.Config(
+            self.app,
+            host=self.host,
+            port=self.port,
+            log_level="info",
+            ws="websockets-sansio",
+        )
+        server = uvicorn.Server(config)
+        await server.serve()
+
+
+if __name__ == "__main__":
+    import anyio
+    import httpx
+
+    from agentpool import AgentPool
+
+    async def test_completions() -> None:
+        """Test the chat completions API."""
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "http://localhost:8000/v1/chat/completions",
+                headers={"Authorization": "Bearer dummy"},
+                json={
+                    "model": "gpt-5-mini",
+                    "messages": [{"role": "user", "content": "Tell me a joke"}],
+                    "stream": True,
+                },
+                timeout=30.0,
+            )
+
+            if response.is_success:
+                for line in response.iter_lines():
+                    if line.startswith("data: "):
+                        data = line[6:]  # Remove "data: " prefix
+                        if data == "[DONE]":
+                            break
+                        chunk = anyenv.load_json(data, return_type=dict)
+                        delta = chunk["choices"][0]["delta"]
+                        if "content" in delta:
+                            print(delta["content"], end="", flush=True)
+                print("\n")
+            else:
+                print("Completions error:", response.text)
+
+    async def test_responses() -> None:
+        """Test the responses API."""
+        timeout = httpx.Timeout(30.0, connect=5.0)
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.post(
+                "http://localhost:8000/v1/responses",
+                headers={"Authorization": "Bearer dummy"},
+                json={
+                    "model": "gpt-5-mini",
+                    "input": "Tell me a three sentence bedtime story about a unicorn.",
+                },
+            )
+            print("Responses result:", response.text)
+
+            if not response.is_success:
+                print("Responses error:", response.text)
+
+    async def main() -> None:
+        """Run server and test both endpoints."""
+        pool = AgentPool()
+        await pool.add_agent("gpt-5-mini", model="openai:gpt-5-mini")
+        async with (
+            OpenAIAPIServer(pool, host="0.0.0.0", port=8000) as server,
+            server.run_context(),
+        ):
+            await anyio.sleep(1)  # Wait for server to start
+            print("Testing completions endpoint...")
+            await test_completions()
+            print("\nTesting responses endpoint...")
+            await test_responses()
+
+    anyio.run(main)

agentpool_storage/__init__.py

@@ -0,0 +1,9 @@
+"""Storage provider package."""
+
+from agentpool_storage.base import StorageProvider
+from agentpool_storage.session_store import SQLSessionStore
+
+__all__ = [
+    "SQLSessionStore",
+    "StorageProvider",
+]