cli2api 0.1.0__py3-none-any.whl

cli2api/api/v1/responses.py

@@ -0,0 +1,255 @@
+"""Responses endpoint - OpenAI Responses API compatible.
+
+This is the newer OpenAI API format that some clients use.
+We translate it to our internal format and use the same provider.
+"""
+
+import time
+import uuid
+from typing import Any, AsyncIterator, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, ConfigDict
+
+from cli2api.api.dependencies import get_provider
+from cli2api.api.utils import parse_model_name
+from cli2api.providers.claude import ClaudeCodeProvider
+from cli2api.schemas.openai import ChatMessage
+from cli2api.streaming.sse import sse_encode, sse_error
+
+router = APIRouter()
+
+
+# === Request Models for Responses API ===
+
+
+class ResponsesInputMessage(BaseModel):
+    """Input message for Responses API."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    role: str
+    content: Any  # Can be string or list of content blocks
+
+
+class ResponsesRequest(BaseModel):
+    """Request body for /v1/responses."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    model: str
+    input: list[ResponsesInputMessage] | str
+    stream: bool = False
+    instructions: Optional[str] = None
+    temperature: Optional[float] = None
+    max_output_tokens: Optional[int] = None
+    # Additional fields
+    tools: Optional[list[Any]] = None
+    tool_choice: Optional[Any] = None
+    metadata: Optional[dict] = None
+
+
+# === Response Models ===
+
+
+class ResponsesOutput(BaseModel):
+    """Output content in response."""
+
+    type: str = "message"
+    id: str
+    role: str = "assistant"
+    content: list[dict]
+
+
+class ResponsesResponse(BaseModel):
+    """Response body for /v1/responses."""
+
+    id: str
+    object: str = "response"
+    created_at: int
+    model: str
+    output: list[ResponsesOutput]
+    usage: Optional[dict] = None
+
+
+def convert_to_chat_messages(request: ResponsesRequest) -> list[ChatMessage]:
+    """Convert Responses API input to ChatMessage list."""
+    messages = []
+
+    # Add instructions as system message
+    if request.instructions:
+        messages.append(ChatMessage(role="system", content=request.instructions))
+
+    # Handle input
+    if isinstance(request.input, str):
+        messages.append(ChatMessage(role="user", content=request.input))
+    else:
+        for msg in request.input:
+            content = msg.content
+            if isinstance(content, list):
+                # Extract text from content blocks
+                texts = []
+                for item in content:
+                    if isinstance(item, dict) and item.get("type") == "text":
+                        texts.append(item.get("text", ""))
+                    elif isinstance(item, str):
+                        texts.append(item)
+                content = "\n".join(texts)
+            elif content is None:
+                content = ""
+
+            role = msg.role
+            if role not in ("system", "user", "assistant"):
+                role = "user"  # Default to user for unknown roles
+
+            messages.append(ChatMessage(role=role, content=str(content)))
+
+    return messages
+
+
+@router.post("/responses")
+async def create_response(
+    request: ResponsesRequest,
+    provider: ClaudeCodeProvider = Depends(get_provider),
+):
+    """Create a response using the Responses API format.
+
+    This endpoint provides compatibility with the OpenAI Responses API.
+    """
+    actual_model = parse_model_name(request.model)
+
+    # Convert to chat messages
+    messages = convert_to_chat_messages(request)
+    response_id = f"resp-{uuid.uuid4().hex[:24]}"
+
+    if request.stream:
+        return StreamingResponse(
+            stream_response(
+                provider=provider,
+                messages=messages,
+                model=actual_model,
+                response_id=response_id,
+            ),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
+        )
+    else:
+        # Non-streaming response
+        try:
+            result = await provider.execute(
+                messages=messages,
+                model=actual_model,
+            )
+        except TimeoutError as e:
+            raise HTTPException(status_code=504, detail=str(e))
+        except RuntimeError as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+        output_id = f"msg-{uuid.uuid4().hex[:24]}"
+
+        return ResponsesResponse(
+            id=response_id,
+            created_at=int(time.time()),
+            model=request.model,
+            output=[
+                ResponsesOutput(
+                    id=output_id,
+                    content=[{"type": "text", "text": result.content}],
+                )
+            ],
+            usage=result.usage,
+        )
+
+
+async def stream_response(
+    provider: ClaudeCodeProvider,
+    messages: list[ChatMessage],
+    model: str,
+    response_id: str,
+) -> AsyncIterator[str]:
+    """Generate SSE events for streaming response."""
+    created = int(time.time())
+    output_id = f"msg-{uuid.uuid4().hex[:24]}"
+    content_buffer = ""
+
+    try:
+        # Send response.created event
+        yield sse_encode({
+            "type": "response.created",
+            "response": {
+                "id": response_id,
+                "object": "response",
+                "created_at": created,
+                "model": model,
+                "output": [],
+            }
+        })
+
+        # Send output_item.added event
+        yield sse_encode({
+            "type": "response.output_item.added",
+            "output_index": 0,
+            "item": {
+                "type": "message",
+                "id": output_id,
+                "role": "assistant",
+                "content": [],
+            }
+        })
+
+        # Stream content
+        async for chunk in provider.execute_stream(messages=messages, model=model):
+            if chunk.content:
+                content_buffer += chunk.content
+                yield sse_encode({
+                    "type": "response.output_text.delta",
+                    "output_index": 0,
+                    "content_index": 0,
+                    "delta": chunk.content,
+                })
+
+        # Send completion events
+        yield sse_encode({
+            "type": "response.output_text.done",
+            "output_index": 0,
+            "content_index": 0,
+            "text": content_buffer,
+        })
+
+        yield sse_encode({
+            "type": "response.output_item.done",
+            "output_index": 0,
+            "item": {
+                "type": "message",
+                "id": output_id,
+                "role": "assistant",
+                "content": [{"type": "text", "text": content_buffer}],
+            }
+        })
+
+        yield sse_encode({
+            "type": "response.completed",
+            "response": {
+                "id": response_id,
+                "object": "response",
+                "created_at": created,
+                "model": model,
+                "output": [{
+                    "type": "message",
+                    "id": output_id,
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": content_buffer}],
+                }],
+            }
+        })
+
+        yield "data: [DONE]\n\n"
+
+    except Exception as e:
+        yield sse_error(str(e))
+        yield "data: [DONE]\n\n"

cli2api/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration module."""
+
+from cli2api.config.settings import Settings
+
+__all__ = ["Settings"]

cli2api/config/settings.py

@@ -0,0 +1,86 @@
+"""Application settings."""
+
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        env_prefix="CLI2API_",
+    )
+
+    # Server
+    host: str = "0.0.0.0"
+    port: int = 8000
+    debug: bool = False
+
+    # CLI Path (auto-detect if not set)
+    claude_cli_path: Optional[str] = Field(
+        default=None,
+        description="Path to claude CLI executable",
+    )
+
+    # Timeout
+    default_timeout: int = Field(
+        default=300,
+        description="Default CLI execution timeout in seconds",
+    )
+
+    # Default model
+    default_model: str = Field(
+        default="sonnet",
+        description="Default model to use if not specified",
+    )
+
+    # Custom models (comma-separated, e.g. "sonnet,opus,haiku")
+    claude_models: Optional[str] = Field(
+        default=None,
+        description="Comma-separated list of Claude models to expose",
+    )
+
+    # Logging
+    log_level: str = "INFO"
+    log_json: bool = Field(
+        default=False,
+        description="Use JSON format for structured logging",
+    )
+
+    def get_claude_models(self) -> list[str]:
+        """Get list of Claude models.
+
+        Claude CLI doesn't have a models cache, so we use defaults
+        or user-configured models.
+        """
+        if self.claude_models:
+            return [m.strip() for m in self.claude_models.split(",")]
+        # Default Claude models (aliases supported by CLI)
+        return ["sonnet", "opus", "haiku"]
+
+    @field_validator("claude_cli_path", mode="before")
+    @classmethod
+    def detect_claude_cli(cls, v: Optional[str]) -> Optional[str]:
+        """Auto-detect claude CLI path if not provided."""
+        if v:
+            return v
+        # Try which first
+        path = shutil.which("claude")
+        if path:
+            return path
+        # Fallback to common paths
+        common_paths = [
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+            Path.home() / ".local/bin/claude",
+        ]
+        for p in common_paths:
+            if Path(p).exists():
+                return str(p)
+        return None

cli2api/main.py

@@ -0,0 +1,143 @@
+"""FastAPI application factory."""
+
+import asyncio
+from contextlib import asynccontextmanager
+from importlib.metadata import version
+
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from cli2api.api.dependencies import get_provider, get_settings
+from cli2api.api.router import api_router
+from cli2api.utils.logging import get_logger, setup_logging
+
+logger = get_logger(__name__)
+
+# Single source of truth for version from pyproject.toml
+__version__ = version("cli2api")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler."""
+    settings = get_settings()
+    provider = get_provider()
+
+    # Setup structured logging
+    setup_logging(
+        level=settings.log_level,
+        json_format=settings.log_json,
+        logger_name=None,  # Configure root logger
+    )
+
+    logger.info(
+        "Starting CLI2API",
+        extra={
+            "version": __version__,
+            "host": settings.host,
+            "port": settings.port,
+            "available_models": provider.supported_models,
+        },
+    )
+
+    yield
+
+    logger.info("CLI2API shutting down")
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Returns:
+        Configured FastAPI application.
+    """
+    app = FastAPI(
+        title="CLI2API",
+        description="OpenAI-compatible API over Claude Code CLI",
+        version=__version__,
+        lifespan=lifespan,
+    )
+
+    # CORS middleware for browser clients
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API routers
+    app.include_router(api_router)
+
+    # Validation error handler with logging
+    @app.exception_handler(RequestValidationError)
+    async def validation_exception_handler(request: Request, exc: RequestValidationError):
+        body = await request.body()
+        logger.error(f"Validation error for {request.method} {request.url}")
+        logger.error(f"Request body: {body.decode()[:1000]}")
+        logger.error(f"Validation errors: {exc.errors()}")
+        return JSONResponse(
+            status_code=422,
+            content={
+                "error": {
+                    "message": "Invalid request format",
+                    "type": "invalid_request_error",
+                    "details": exc.errors(),
+                }
+            },
+        )
+
+    # Health check endpoint
+    @app.get("/health")
+    async def health():
+        """Health check endpoint with CLI availability check."""
+        settings = get_settings()
+
+        async def check_cli(path: str | None) -> str:
+            """Check if a CLI tool is available."""
+            if not path:
+                return "not_configured"
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    path,
+                    "--version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                await asyncio.wait_for(proc.communicate(), timeout=2.0)
+                return "available" if proc.returncode == 0 else "error"
+            except Exception:
+                return "unavailable"
+
+        claude_status = await check_cli(settings.claude_cli_path)
+
+        return {
+            "status": "healthy" if claude_status == "available" else "degraded",
+            "cli": {"claude": claude_status},
+        }
+
+    # Root endpoint
+    @app.get("/")
+    async def root():
+        """Root endpoint with API info."""
+        provider = get_provider()
+        return {
+            "name": "CLI2API",
+            "version": __version__,
+            "description": "OpenAI-compatible API over Claude Code CLI",
+            "available_models": [f"claude: {m}" for m in provider.supported_models],
+            "endpoints": {
+                "chat_completions": "/v1/chat/completions",
+                "models": "/v1/models",
+                "health": "/health",
+            },
+        }
+
+    return app
+
+
+# Application instance
+app = create_app()

cli2api/providers/__init__.py

@@ -0,0 +1,5 @@
+"""Claude Code CLI provider."""
+
+from cli2api.providers.claude import ClaudeCodeProvider
+
+__all__ = ["ClaudeCodeProvider"]