local-openai2anthropic 0.1.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

local_openai2anthropic/daemon_runner.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""
+Daemon runner - this module is executed as a standalone script in the child process.
+"""
+
+import atexit
+import os
+import signal
+import sys
+from pathlib import Path
+from datetime import datetime
+
+PID_FILE = Path.home() / ".local" / "share" / "oa2a" / "oa2a.pid"
+
+
+def log_message(msg: str) -> None:
+    """Write message to both stdout and parent process communication"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{timestamp}] {msg}"
+    print(line, file=sys.stderr)
+    sys.stderr.flush()
+
+
+def _write_pid(pid: int) -> None:
+    """Write PID to pidfile."""
+    try:
+        PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+        PID_FILE.write_text(str(pid))
+        log_message(f"PID written to {PID_FILE}: {pid}")
+    except Exception as e:
+        log_message(f"Failed to write PID file: {e}")
+
+
+def _remove_pid() -> None:
+    """Remove pidfile."""
+    try:
+        if PID_FILE.exists():
+            PID_FILE.unlink()
+            log_message(f"PID file removed: {PID_FILE}")
+    except OSError:
+        pass
+
+
+def _signal_handler(signum, frame):
+    """Handle termination signals."""
+    sig_name = signal.Signals(signum).name
+    log_message(f"Received signal {sig_name}, shutting down...")
+    _remove_pid()
+    sys.exit(0)
+
+
+def run_server():
+    """Run the server in daemon mode."""
+    try:
+        # Write current PID to file (this is the correct PID for the daemon)
+        current_pid = os.getpid()
+        _write_pid(current_pid)
+
+        # Register cleanup on exit
+        atexit.register(_remove_pid)
+
+        # Setup signal handlers
+        signal.signal(signal.SIGTERM, _signal_handler)
+        signal.signal(signal.SIGINT, _signal_handler)
+
+        log_message(f"Starting daemon server (PID: {current_pid})...")
+
+        # Add the src directory to path if needed
+        current_file = Path(__file__).resolve()
+        package_dir = current_file.parent
+
+        if str(package_dir) not in sys.path:
+            sys.path.insert(0, str(package_dir))
+
+        # Import and run the main server
+        from local_openai2anthropic.main import create_app
+        from local_openai2anthropic.config import get_settings
+
+        import uvicorn
+
+        settings = get_settings()
+
+        log_message(f"Configuration loaded:")
+        log_message(f"  Host: {settings.host}")
+        log_message(f"  Port: {settings.port}")
+        log_message(f"  Log Level: {settings.log_level}")
+        log_message(f"  OpenAI Base URL: {settings.openai_base_url}")
+
+        # Validate required settings
+        if not settings.openai_api_key:
+            log_message("Error: OA2A_OPENAI_API_KEY is required but not set")
+            sys.exit(1)
+
+        app = create_app(settings)
+
+        log_message(f"Starting uvicorn on {settings.host}:{settings.port}")
+
+        uvicorn.run(
+            app,
+            host=settings.host,
+            port=settings.port,
+            log_level=settings.log_level.lower(),
+            timeout_keep_alive=300,
+        )
+
+    except Exception as e:
+        log_message(f"Fatal error in daemon: {e}")
+        import traceback
+        traceback.print_exc()
+        _remove_pid()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run_server()

local_openai2anthropic/main.py

@@ -3,6 +3,7 @@
 Main entry point for the local-openai2anthropic proxy server.
 """
 
+import argparse
 import logging
 import sys
 
@@ -20,25 +21,25 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     """Create and configure the FastAPI application."""
     if settings is None:
         settings = get_settings()
-    
+
     # Configure logging
     logging.basicConfig(
         level=getattr(logging, settings.log_level.upper()),
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )
-    
+
     # Create FastAPI app
     app = FastAPI(
         title="local-openai2anthropic",
         description="A proxy server that converts Anthropic Messages API to OpenAI API",
-        version="0.1.0",
+        version="0.2.0",
         docs_url="/docs",
         redoc_url="/redoc",
     )
-    
+
     # Store settings in app state
     app.state.settings = settings
-    
+
     # Add CORS middleware
     app.add_middleware(
         CORSMiddleware,
@@ -47,16 +48,17 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         allow_methods=settings.cors_methods,
         allow_headers=settings.cors_headers,
     )
-    
+
     # Add API key authentication middleware if configured
     if settings.api_key:
+
         @app.middleware("http")
         async def auth_middleware(request: Request, call_next):
             """Validate API key if configured."""
             # Skip auth for docs and health check
             if request.url.path in ["/docs", "/redoc", "/openapi.json", "/health"]:
                 return await call_next(request)
-            
+
             auth_header = request.headers.get("Authorization", "")
             if not auth_header.startswith("Bearer "):
                 error_response = AnthropicErrorResponse(
@@ -69,7 +71,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                     status_code=401,
                     content=error_response.model_dump(),
                 )
-            
+
             token = auth_header[7:]  # Remove "Bearer " prefix
             if token != settings.api_key:
                 error_response = AnthropicErrorResponse(
@@ -82,12 +84,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                     status_code=401,
                     content=error_response.model_dump(),
                 )
-            
+
             return await call_next(request)
-    
+
     # Include routers
     app.include_router(router)
-    
+
     # Exception handlers
     @app.exception_handler(HTTPException)
     async def http_exception_handler(request: Request, exc: HTTPException):
@@ -98,7 +100,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                 status_code=exc.status_code,
                 content=exc.detail,
             )
-        
+
         error_response = AnthropicErrorResponse(
             error=AnthropicError(
                 type="api_error",
@@ -109,7 +111,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
             status_code=exc.status_code,
             content=error_response.model_dump(),
         )
-    
+
     @app.exception_handler(Exception)
     async def general_exception_handler(request: Request, exc: Exception):
         """Handle unexpected exceptions."""
@@ -124,33 +126,31 @@ def create_app(settings: Settings | None = None) -> FastAPI:
             status_code=500,
             content=error_response.model_dump(),
         )
-    
+
     return app
 
 
-def main() -> None:
-    """Main entry point."""
-    # Load settings
-    settings = get_settings()
-    
+def run_foreground(settings: Settings) -> None:
+    """Run server in foreground mode (blocking)."""
     # Validate required settings
     if not settings.openai_api_key:
         print(
-            "Error: OPENAI_API_KEY environment variable is required.\n"
+            "Error: OA2A_OPENAI_API_KEY environment variable is required.\n"
             "Set it via:\n"
             "  - Environment variable: export OA2A_OPENAI_API_KEY='your-key'\n"
-            "  - Or create a .env file with OPENAI_API_KEY=your-key",
+            "  - Or create a .env file with OA2A_OPENAI_API_KEY=your-key",
             file=sys.stderr,
         )
         sys.exit(1)
-    
+
     # Create app
     app = create_app(settings)
-    
+
     # Run server
-    print(f"Starting local-openai2anthropic server on {settings.host}:{settings.port}")
+    print(f"Starting server on {settings.host}:{settings.port}")
     print(f"Proxying to: {settings.openai_base_url}")
-    
+    print("Press Ctrl+C to stop\n")
+
     uvicorn.run(
         app,
         host=settings.host,
@@ -160,5 +160,157 @@ def main() -> None:
     )
 
 
+def main() -> None:
+    """Main entry point with subcommand support."""
+    # Create main parser
+    parser = argparse.ArgumentParser(
+        prog="oa2a",
+        description="A proxy server that converts Anthropic Messages API to OpenAI API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  oa2a start              # Start server in background
+  oa2a stop               # Stop background server
+  oa2a restart            # Restart background server
+  oa2a status             # Check server status
+  oa2a logs               # View server logs
+  oa2a logs -f            # Follow server logs (tail -f)
+  oa2a                    # Run server in foreground (default behavior)
+        """.strip(),
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s 0.2.0",
+    )
+
+    # Create subparsers for commands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # start command
+    start_parser = subparsers.add_parser("start", help="Start server in background")
+    start_parser.add_argument(
+        "--host",
+        default=None,
+        help="Server host (default: 0.0.0.0)",
+    )
+    start_parser.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="Server port (default: 8080)",
+    )
+    start_parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["debug", "info", "warning", "error"],
+        help="Logging level (default: info)",
+    )
+
+    # stop command
+    stop_parser = subparsers.add_parser("stop", help="Stop background server")
+    stop_parser.add_argument(
+        "-f", "--force",
+        action="store_true",
+        help="Force kill the server",
+    )
+
+    # restart command
+    restart_parser = subparsers.add_parser("restart", help="Restart background server")
+    restart_parser.add_argument(
+        "--host",
+        default=None,
+        help="Server host (default: 0.0.0.0)",
+    )
+    restart_parser.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="Server port (default: 8080)",
+    )
+    restart_parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["debug", "info", "warning", "error"],
+        help="Logging level (default: info)",
+    )
+
+    # status command
+    status_parser = subparsers.add_parser("status", help="Check server status")
+
+    # logs command
+    logs_parser = subparsers.add_parser("logs", help="View server logs")
+    logs_parser.add_argument(
+        "-f", "--follow",
+        action="store_true",
+        help="Follow log output (like tail -f)",
+    )
+    logs_parser.add_argument(
+        "-n", "--lines",
+        type=int,
+        default=50,
+        help="Number of lines to show (default: 50)",
+    )
+
+    args = parser.parse_args()
+
+    # Import daemon module only when needed
+    from local_openai2anthropic import daemon
+
+    # Handle subcommands
+    if args.command == "start":
+        # Get settings for defaults
+        settings = get_settings()
+        host = args.host or settings.host
+        port = args.port or settings.port
+
+        success = daemon.start_daemon(
+            host=host,
+            port=port,
+            log_level=args.log_level,
+        )
+        sys.exit(0 if success else 1)
+
+    elif args.command == "stop":
+        success = daemon.stop_daemon(force=args.force)
+        sys.exit(0 if success else 1)
+
+    elif args.command == "restart":
+        # Get settings for defaults
+        settings = get_settings()
+        host = args.host or settings.host
+        port = args.port or settings.port
+
+        success = daemon.restart_daemon(
+            host=host,
+            port=port,
+            log_level=args.log_level,
+        )
+        sys.exit(0 if success else 1)
+
+    elif args.command == "status":
+        running, pid, config = daemon.get_status()
+        if running and config:
+            host = config.get("host", "0.0.0.0")
+            port = config.get("port", 8080)
+            print(f"Server is running (PID: {pid})")
+            print(f"Listening on: {host}:{port}")
+        elif running:
+            print(f"Server is running (PID: {pid})")
+        else:
+            print("Server is not running")
+        sys.exit(0)
+
+    elif args.command == "logs":
+        success = daemon.show_logs(follow=args.follow, lines=args.lines)
+        sys.exit(0 if success else 1)
+
+    else:
+        # No command - run in foreground (original behavior)
+        settings = get_settings()
+        run_foreground(settings)
+
+
 if __name__ == "__main__":
     main()

local_openai2anthropic/openai_types.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0
+"""
+OpenAI API type definitions for compatibility with vLLM/SGLang responses.
+
+This module defines Pydantic models compatible with OpenAI API responses,
+these models support additional fields like `reasoning_content` that are
+returned by vLLM/SGLang but not present in the official OpenAI SDK.
+"""
+
+from typing import Any, Literal, Optional, TypedDict
+
+from pydantic import BaseModel
+
+
+# TypedDict types for parameters (used as dict in code)
+class ChatCompletionToolFunction(TypedDict):
+    """Function definition for a tool."""
+
+    name: str
+    description: str
+    parameters: dict[str, Any]
+
+
+class ChatCompletionToolParam(TypedDict):
+    """Tool parameter for chat completion."""
+
+    type: Literal["function"]
+    function: ChatCompletionToolFunction
+
+
+class CompletionCreateParams(TypedDict, total=False):
+    """Parameters for creating a chat completion."""
+
+    model: str
+    messages: list[dict[str, Any]]
+    max_tokens: int
+    temperature: float
+    top_p: float
+    top_k: int
+    stream: bool
+    stop: list[str]
+    tools: list[ChatCompletionToolParam]
+    tool_choice: str | dict[str, Any]
+    stream_options: dict[str, Any]
+    # Additional fields for vLLM/SGLang compatibility
+    chat_template_kwargs: dict[str, Any]
+    # Internal field for server tools config
+    _server_tools_config: dict[str, dict[str, Any]]
+
+
+# Pydantic models for API responses
+class Function(BaseModel):
+    """A function call."""
+
+    name: str
+    arguments: str
+
+
+class ChatCompletionMessageToolCall(BaseModel):
+    """A tool call in a chat completion message."""
+
+    id: str
+    type: str = "function"
+    function: Function
+
+
+class ChatCompletionMessage(BaseModel):
+    """A chat completion message."""
+
+    role: str
+    content: Optional[str] = None
+    tool_calls: Optional[list[ChatCompletionMessageToolCall]] = None
+    # Additional field for reasoning content (thinking) from vLLM/SGLang
+    reasoning_content: Optional[str] = None
+
+
+class Choice(BaseModel):
+    """A choice in a chat completion response."""
+
+    index: int = 0
+    message: ChatCompletionMessage
+    finish_reason: Optional[str] = None
+
+
+class FunctionDelta(BaseModel):
+    """A function call delta."""
+
+    name: Optional[str] = None
+    arguments: Optional[str] = None
+
+
+class ChatCompletionDeltaToolCall(BaseModel):
+    """A tool call delta in a streaming response."""
+
+    index: int = 0
+    id: Optional[str] = None
+    type: Optional[str] = None
+    function: Optional[FunctionDelta] = None
+
+
+class ChoiceDelta(BaseModel):
+    """A delta in a streaming chat completion response."""
+
+    role: Optional[str] = None
+    content: Optional[str] = None
+    tool_calls: Optional[list[ChatCompletionDeltaToolCall]] = None
+    # Additional field for reasoning content (thinking) from vLLM/SGLang
+    reasoning_content: Optional[str] = None
+
+
+class StreamingChoice(BaseModel):
+    """A choice in a streaming chat completion response."""
+
+    index: int = 0
+    delta: ChoiceDelta
+    finish_reason: Optional[str] = None
+
+
+class CompletionUsage(BaseModel):
+    """Usage statistics for a completion request."""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    # Optional cache-related fields
+    cache_creation_input_tokens: Optional[int] = None
+    cache_read_input_tokens: Optional[int] = None
+
+
+class ChatCompletion(BaseModel):
+    """A chat completion response."""
+
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: list[Choice]
+    usage: Optional[CompletionUsage] = None
+
+
+class ChatCompletionChunk(BaseModel):
+    """A chunk in a streaming chat completion response."""
+
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: list[StreamingChoice]
+    usage: Optional[CompletionUsage] = None