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

local_openai2anthropic/__init__.py

@@ -3,7 +3,7 @@
 local-openai2anthropic: A proxy server that converts Anthropic Messages API to OpenAI API.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.3"
 
 from local_openai2anthropic.protocol import (
     AnthropicError,

local_openai2anthropic/__main__.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Allow running as python -m local_openai2anthropic"""
+
+from local_openai2anthropic.main import main
+
+if __name__ == "__main__":
+    main()

local_openai2anthropic/config.py

@@ -20,7 +20,7 @@ class Settings(BaseSettings):
     )
     
     # OpenAI API Configuration
-    openai_api_key: str
+    openai_api_key: Optional[str] = None
     openai_base_url: str = "https://api.openai.com/v1"
     openai_org_id: Optional[str] = None
     openai_project_id: Optional[str] = None
@@ -40,7 +40,7 @@ class Settings(BaseSettings):
     cors_headers: list[str] = ["*"]
     
     # Logging
-    log_level: str = "INFO"
+    log_level: str = "DEBUG"
 
     # Tavily Web Search Configuration
     tavily_api_key: Optional[str] = None

local_openai2anthropic/converter.py

@@ -5,23 +5,13 @@ Core conversion logic between Anthropic and OpenAI formats.
 
 import json
 import logging
-import time
-from typing import Any, AsyncGenerator, Optional
-
-logger = logging.getLogger(__name__)
+from typing import Any, Optional
 
 from anthropic.types import (
     ContentBlock,
-    ContentBlockDeltaEvent,
-    ContentBlockStartEvent,
-    ContentBlockStopEvent,
     Message,
-    MessageDeltaEvent,
     MessageParam,
-    MessageStartEvent,
-    MessageStopEvent,
     TextBlock,
-    TextDelta,
     ToolUseBlock,
 )
 from anthropic.types.message_create_params import MessageCreateParams
@@ -175,11 +165,15 @@ def convert_anthropic_to_openai(
     
     # Handle thinking parameter
     # vLLM/SGLang use chat_template_kwargs.thinking to toggle thinking mode
+    # Some models use "thinking", others use "enable_thinking", so we include both
     if thinking and isinstance(thinking, dict):
         thinking_type = thinking.get("type")
         if thinking_type == "enabled":
-            # Enable thinking mode for vLLM/SGLang
-            params["chat_template_kwargs"] = {"thinking": True}
+            # Enable thinking mode - include both variants for compatibility
+            params["chat_template_kwargs"] = {
+                "thinking": True,
+                "enable_thinking": True,
+            }
 
             # Log if budget_tokens was provided but will be ignored
             budget_tokens = thinking.get("budget_tokens")
@@ -191,10 +185,16 @@ def convert_anthropic_to_openai(
                 )
         else:
             # Default to disabled thinking mode if not explicitly enabled
-            params["chat_template_kwargs"] = {"thinking": False}
+            params["chat_template_kwargs"] = {
+                "thinking": False,
+                "enable_thinking": False,
+            }
     else:
         # Default to disabled thinking mode when thinking is not provided
-        params["chat_template_kwargs"] = {"thinking": False}
+        params["chat_template_kwargs"] = {
+            "thinking": False,
+            "enable_thinking": False,
+        }
 
     # Store server tool configs for later use by router
     if server_tools_config:
@@ -361,12 +361,25 @@ def convert_openai_to_anthropic(
     Returns:
         Anthropic Message response
     """
+    from anthropic.types.beta import BetaThinkingBlock
+    
     choice = completion.choices[0]
     message = choice.message
     
     # Convert content blocks
     content: list[ContentBlock] = []
     
+    # Add reasoning content (thinking) first if present
+    reasoning_content = getattr(message, 'reasoning_content', None)
+    if reasoning_content:
+        content.append(
+            BetaThinkingBlock(
+                type="thinking",
+                thinking=reasoning_content,
+                signature="",  # Signature not available from OpenAI format
+            )
+        )
+    
     # Add text content if present
     if message.content:
         if isinstance(message.content, str):
@@ -426,181 +439,3 @@ def convert_openai_to_anthropic(
     }
     
     return Message.model_validate(message_dict)
-
-
-async def convert_openai_stream_to_anthropic(
-    stream: AsyncGenerator[ChatCompletionChunk, None],
-    model: str,
-    enable_ping: bool = False,
-    ping_interval: float = 15.0,
-) -> AsyncGenerator[dict, None]:
-    """
-    Convert OpenAI streaming response to Anthropic streaming events.
-    
-    Args:
-        stream: OpenAI chat completion stream
-        model: Model name
-        enable_ping: Whether to send periodic ping events
-        ping_interval: Interval between ping events in seconds
-        
-    Yields:
-        Anthropic MessageStreamEvent objects as dicts
-    """
-    message_id = f"msg_{int(time.time() * 1000)}"
-    first_chunk = True
-    content_block_started = False
-    content_block_index = 0
-    current_tool_call: Optional[dict[str, Any]] = None
-    finish_reason: Optional[str] = None
-    
-    # Track usage for final message_delta
-    input_tokens = 0
-    output_tokens = 0
-    
-    last_ping_time = time.time()
-    
-    async for chunk in stream:
-        # Send ping events if enabled and interval has passed
-        if enable_ping:
-            current_time = time.time()
-            if current_time - last_ping_time >= ping_interval:
-                yield {"type": "ping"}
-                last_ping_time = current_time
-        
-        # First chunk: message_start event
-        if first_chunk:
-            if chunk.usage:
-                input_tokens = chunk.usage.prompt_tokens
-                output_tokens = chunk.usage.completion_tokens
-            
-            yield {
-                "type": "message_start",
-                "message": {
-                    "id": message_id,
-                    "type": "message",
-                    "role": "assistant",
-                    "content": [],
-                    "model": model,
-                    "stop_reason": None,
-                    "stop_sequence": None,
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": 0,
-                        "cache_creation_input_tokens": None,
-                        "cache_read_input_tokens": None,
-                    },
-                },
-            }
-            first_chunk = False
-            continue
-        
-        # Handle usage-only chunks (last chunk)
-        if not chunk.choices:
-            if chunk.usage:
-                input_tokens = chunk.usage.prompt_tokens
-                output_tokens = chunk.usage.completion_tokens
-                
-                # Close any open content block
-                if content_block_started:
-                    yield {
-                        "type": "content_block_stop",
-                        "index": content_block_index,
-                    }
-                
-                # Message delta with final usage
-                stop_reason_map = {
-                    "stop": "end_turn",
-                    "length": "max_tokens",
-                    "tool_calls": "tool_use",
-                }
-                yield {
-                    "type": "message_delta",
-                    "delta": {
-                        "stop_reason": stop_reason_map.get(finish_reason or "stop", "end_turn"),
-                    },
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": output_tokens,
-                        "cache_creation_input_tokens": getattr(chunk.usage, "cache_creation_input_tokens", None),
-                        "cache_read_input_tokens": getattr(chunk.usage, "cache_read_input_tokens", None),
-                    },
-                }
-            continue
-        
-        choice = chunk.choices[0]
-        delta = choice.delta
-        
-        # Track finish reason
-        if choice.finish_reason:
-            finish_reason = choice.finish_reason
-            continue
-        
-        # Handle content
-        if delta.content:
-            if not content_block_started:
-                # Start text content block
-                yield {
-                    "type": "content_block_start",
-                    "index": content_block_index,
-                    "content_block": {"type": "text", "text": ""},
-                }
-                content_block_started = True
-            
-            if delta.content:
-                yield {
-                    "type": "content_block_delta",
-                    "index": content_block_index,
-                    "delta": {"type": "text_delta", "text": delta.content},
-                }
-        
-        # Handle tool calls
-        if delta.tool_calls:
-            tool_call = delta.tool_calls[0]
-            
-            if tool_call.id:
-                # Close previous content block if any
-                if content_block_started:
-                    yield {
-                        "type": "content_block_stop",
-                        "index": content_block_index,
-                    }
-                    content_block_started = False
-                    content_block_index += 1
-                
-                # Start new tool_use block
-                current_tool_call = {
-                    "id": tool_call.id,
-                    "name": tool_call.function.name if tool_call.function else "",
-                    "arguments": "",
-                }
-                yield {
-                    "type": "content_block_start",
-                    "index": content_block_index,
-                    "content_block": {
-                        "type": "tool_use",
-                        "id": tool_call.id,
-                        "name": tool_call.function.name if tool_call.function else "",
-                        "input": {},
-                    },
-                }
-                content_block_started = True
-                
-            elif tool_call.function and tool_call.function.arguments:
-                # Continue tool call arguments
-                args = tool_call.function.arguments
-                current_tool_call["arguments"] += args
-                yield {
-                    "type": "content_block_delta",
-                    "index": content_block_index,
-                    "delta": {"type": "input_json_delta", "partial_json": args},
-                }
-    
-    # Close final content block
-    if content_block_started:
-        yield {
-            "type": "content_block_stop",
-            "index": content_block_index,
-        }
-    
-    # Message stop event
-    yield {"type": "message_stop"}

local_openai2anthropic/daemon.py

@@ -0,0 +1,382 @@
+# SPDX-License-Identifier: Apache-2.0
+"""
+Daemon process management for local-openai2anthropic server.
+"""
+
+import json
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+# Constants
+DATA_DIR = Path.home() / ".local" / "share" / "oa2a"
+PID_FILE = DATA_DIR / "oa2a.pid"
+CONFIG_FILE = DATA_DIR / "oa2a.json"
+LOG_FILE = DATA_DIR / "oa2a.log"
+
+
+def _ensure_dirs() -> None:
+    """Ensure pid/log directories exist."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _read_pid() -> Optional[int]:
+    """Read PID from pidfile."""
+    try:
+        if PID_FILE.exists():
+            return int(PID_FILE.read_text().strip())
+    except (ValueError, OSError):
+        pass
+    return None
+
+
+def _remove_pid() -> None:
+    """Remove pidfile."""
+    try:
+        if PID_FILE.exists():
+            PID_FILE.unlink()
+    except OSError:
+        pass
+
+
+def _save_daemon_config(host: str, port: int) -> None:
+    """Save daemon configuration to file."""
+    _ensure_dirs()
+    config = {
+        "host": host,
+        "port": port,
+        "started_at": time.time(),
+    }
+    try:
+        CONFIG_FILE.write_text(json.dumps(config))
+    except OSError:
+        pass
+
+
+def _load_daemon_config() -> Optional[dict]:
+    """Load daemon configuration from file."""
+    try:
+        if CONFIG_FILE.exists():
+            return json.loads(CONFIG_FILE.read_text())
+    except (OSError, json.JSONDecodeError):
+        pass
+    return None
+
+
+def _remove_daemon_config() -> None:
+    """Remove daemon configuration file."""
+    try:
+        if CONFIG_FILE.exists():
+            CONFIG_FILE.unlink()
+    except OSError:
+        pass
+
+
+def _is_process_running(pid: int) -> bool:
+    """Check if a process with given PID is running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def _is_port_in_use(port: int, host: str = "0.0.0.0") -> bool:
+    """Check if a port is already in use."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            result = s.connect_ex((host, port))
+            return result == 0
+    except Exception:
+        return False
+
+
+def _cleanup_stale_pidfile() -> None:
+    """Remove pidfile if the process is not running."""
+    pid = _read_pid()
+    if pid is not None and not _is_process_running(pid):
+        _remove_pid()
+        _remove_daemon_config()
+
+
+def get_status() -> tuple[bool, Optional[int], Optional[dict]]:
+    """
+    Get daemon status.
+
+    Returns:
+        Tuple of (is_running, pid, config)
+    """
+    _cleanup_stale_pidfile()
+    pid = _read_pid()
+    config = _load_daemon_config()
+    if pid is not None and _is_process_running(pid):
+        return True, pid, config
+    return False, None, None
+
+
+def start_daemon(
+    host: str = "0.0.0.0",
+    port: int = 8080,
+    log_level: str = "info",
+) -> bool:
+    """
+    Start the server as a background daemon.
+
+    Args:
+        host: Server host
+        port: Server port
+        log_level: Logging level
+
+    Returns:
+        True if started successfully, False otherwise
+    """
+    _cleanup_stale_pidfile()
+
+    pid = _read_pid()
+    if pid is not None:
+        config = _load_daemon_config()
+        actual_port = config.get("port", port) if config else port
+        print(f"Server is already running (PID: {pid}, port: {actual_port})", file=sys.stderr)
+        print(f"Use 'oa2a logs' to view output", file=sys.stderr)
+        return False
+
+    # Check if port is already in use
+    if _is_port_in_use(port):
+        print(f"Error: Port {port} is already in use", file=sys.stderr)
+        print(f"Another process may be listening on this port", file=sys.stderr)
+        return False
+
+    _ensure_dirs()
+
+    # Prepare the command to run the daemon runner as a separate script
+    daemon_runner_path = Path(__file__).parent / "daemon_runner.py"
+
+    # Prepare environment - the daemon runner will use these env vars
+    env = os.environ.copy()
+    env["OA2A_HOST"] = host
+    env["OA2A_PORT"] = str(port)
+    env["OA2A_LOG_LEVEL"] = log_level.upper()
+
+    cmd = [
+        sys.executable,
+        str(daemon_runner_path),
+    ]
+
+    try:
+        # Open log file
+        log_fd = open(LOG_FILE, "a")
+
+        # Write a marker to log
+        from datetime import datetime
+        log_fd.write(f"\n\n[{datetime.now()}] Starting oa2a daemon...\n")
+        log_fd.flush()
+
+        # Start the process - use setsid on Unix to create new session
+        kwargs = {
+            "stdout": log_fd,
+            "stderr": subprocess.STDOUT,
+            "env": env,
+        }
+
+        if sys.platform != "win32":
+            # On Unix, start in a new session so it survives parent exit
+            kwargs["start_new_session"] = True
+
+        process = subprocess.Popen(cmd, **kwargs)
+
+        # Don't wait - close file descriptor in parent but child keeps it open
+        log_fd.close()
+
+        # Give the process a moment to fail (e.g., port in use)
+        time.sleep(0.5)
+
+        # Check if process is still running
+        if process.poll() is not None:
+            # Process exited immediately
+            print("Failed to start server - check logs with 'oa2a logs'", file=sys.stderr)
+            return False
+
+        # Wait a bit more for the server to actually start
+        time.sleep(0.5)
+
+        # Check if port is now in use (server started successfully)
+        for _ in range(10):
+            if _is_port_in_use(port, "127.0.0.1"):
+                break
+            time.sleep(0.2)
+        else:
+            # Port never became active, check if process died
+            if process.poll() is not None:
+                print("Server process exited unexpectedly - check logs", file=sys.stderr)
+                return False
+
+        # Save the configuration
+        _save_daemon_config(host, port)
+
+        print(f"Server started (PID: {process.pid})")
+        print(f"Listening on {host}:{port}")
+        print(f"Logs: {LOG_FILE}")
+
+        return True
+
+    except Exception as e:
+        print(f"Failed to start server: {e}", file=sys.stderr)
+        return False
+
+
+def stop_daemon(force: bool = False) -> bool:
+    """
+    Stop the background daemon.
+
+    Args:
+        force: If True, use SIGKILL instead of SIGTERM
+
+    Returns:
+        True if stopped successfully, False otherwise
+    """
+    _cleanup_stale_pidfile()
+
+    pid = _read_pid()
+    if pid is None:
+        print("Server is not running")
+        return True
+
+    try:
+        # Send signal
+        signal_num = signal.SIGKILL if force else signal.SIGTERM
+        os.kill(pid, signal_num)
+
+        # Wait for process to terminate
+        for _ in range(50):  # Wait up to 5 seconds
+            if not _is_process_running(pid):
+                break
+            time.sleep(0.1)
+
+        if _is_process_running(pid):
+            if not force:
+                print(f"Server did not stop gracefully, use -f to force kill", file=sys.stderr)
+                return False
+            # Force kill
+            os.kill(pid, signal.SIGKILL)
+            time.sleep(0.2)
+
+        _remove_pid()
+        _remove_daemon_config()
+        print(f"Server stopped (PID: {pid})")
+        return True
+
+    except (OSError, ProcessLookupError) as e:
+        _remove_pid()
+        _remove_daemon_config()
+        print(f"Server stopped (PID: {pid})")
+        return True
+    except Exception as e:
+        print(f"Failed to stop server: {e}", file=sys.stderr)
+        return False
+
+
+def restart_daemon(
+    host: str = "0.0.0.0",
+    port: int = 8080,
+    log_level: str = "info",
+) -> bool:
+    """
+    Restart the background daemon.
+
+    Args:
+        host: Server host
+        port: Server port
+        log_level: Logging level
+
+    Returns:
+        True if restarted successfully, False otherwise
+    """
+    print("Restarting server...")
+    stop_daemon()
+    # Small delay to ensure port is released
+    time.sleep(0.5)
+    return start_daemon(host, port, log_level)
+
+
+def show_logs(follow: bool = False, lines: int = 50) -> bool:
+    """
+    Show server logs.
+
+    Args:
+        follow: If True, follow log output (like tail -f)
+        lines: Number of lines to show from the end
+
+    Returns:
+        True if successful, False otherwise
+    """
+    if not LOG_FILE.exists():
+        print("No log file found", file=sys.stderr)
+        return False
+
+    try:
+        if follow:
+            # Use subprocess to tail -f
+            try:
+                subprocess.run(
+                    ["tail", "-f", "-n", str(lines), str(LOG_FILE)],
+                    check=True,
+                )
+            except KeyboardInterrupt:
+                pass
+        else:
+            # Read and print last N lines
+            with open(LOG_FILE, "r") as f:
+                content = f.readlines()
+                # Print last N lines
+                for line in content[-lines:]:
+                    print(line, end="")
+
+        return True
+
+    except Exception as e:
+        print(f"Failed to read logs: {e}", file=sys.stderr)
+        return False
+
+
+def run_foreground(
+    host: str = "0.0.0.0",
+    port: int = 8080,
+    log_level: str = "info",
+) -> None:
+    """
+    Run the server in foreground (blocking mode).
+
+    This is the original behavior for compatibility.
+    """
+    # Import here to avoid circular imports
+    from local_openai2anthropic.main import create_app
+    from local_openai2anthropic.config import get_settings
+
+    import uvicorn
+
+    # Override settings with command line values
+    os.environ["OA2A_HOST"] = host
+    os.environ["OA2A_PORT"] = str(port)
+    os.environ["OA2A_LOG_LEVEL"] = log_level.upper()
+
+    settings = get_settings()
+
+    app = create_app(settings)
+
+    print(f"Starting server on {host}:{port}")
+    print(f"Proxying to: {settings.openai_base_url}")
+    print("Press Ctrl+C to stop")
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level=log_level.lower(),
+        timeout_keep_alive=300,
+    )