local-openai2anthropic 0.2.3__py3-none-any.whl → 0.3.6__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.2.3"
+__version__ = "0.3.6"
 
 from local_openai2anthropic.protocol import (
     AnthropicError,

local_openai2anthropic/config.py

@@ -3,44 +3,137 @@
 Configuration settings for the proxy server.
 """
 
+import sys
 from functools import lru_cache
+from pathlib import Path
 from typing import Optional
 
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import BaseModel, ConfigDict
 
 
-class Settings(BaseSettings):
-    """Application settings loaded from environment variables."""
-    
-    model_config = SettingsConfigDict(
-        env_prefix="OA2A_",  # OpenAI-to-Anthropic prefix
-        env_file=".env",
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-    )
-    
+def get_config_dir() -> Path:
+    """Get platform-specific config directory.
+
+    Returns:
+        Path to the config directory (~/.oa2a)
+    """
+    return Path.home() / ".oa2a"
+
+
+def get_config_file() -> Path:
+    """Get config file path.
+
+    Returns:
+        Path to the config file (~/.oa2a/config.toml)
+    """
+    return get_config_dir() / "config.toml"
+
+
+def create_default_config() -> bool:
+    """Create default config file if not exists.
+
+    Returns:
+        True if a new config file was created, False if it already exists
+    """
+    config_file = get_config_file()
+    if config_file.exists():
+        return False
+
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Set restrictive permissions (0o600) for the config directory on Unix-like systems
+    if sys.platform != "win32":
+        config_dir.chmod(0o700)
+
+    default_config = """# OA2A Configuration File
+# Place this file at ~/.oa2a/config.toml
+
+# OpenAI API Configuration
+openai_api_key = ""
+openai_base_url = "https://api.openai.com/v1"
+openai_org_id = ""
+openai_project_id = ""
+
+# Server Configuration
+host = "0.0.0.0"
+port = 8080
+request_timeout = 300.0
+
+# API Key for authenticating requests to this server (optional)
+api_key = ""
+
+# CORS settings
+cors_origins = ["*"]
+cors_credentials = true
+cors_methods = ["*"]
+cors_headers = ["*"]
+
+# Logging
+log_level = "INFO"
+log_dir = ""  # Empty uses platform-specific default
+
+# Tavily Web Search Configuration
+tavily_api_key = ""
+tavily_timeout = 30.0
+tavily_max_results = 5
+websearch_max_uses = 5
+"""
+    config_file.write_text(default_config, encoding="utf-8")
+
+    # Set restrictive permissions (0o600) for the config file on Unix-like systems
+    if sys.platform != "win32":
+        config_file.chmod(0o600)
+
+    return True
+
+
+def load_config_from_file() -> dict:
+    """Load configuration from TOML file.
+
+    Returns:
+        Dictionary containing configuration values, empty dict if file doesn't exist
+    """
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        import tomli as tomllib
+
+    config_file = get_config_file()
+    if not config_file.exists():
+        return {}
+    with open(config_file, "rb") as f:
+        return tomllib.load(f)
+
+
+class Settings(BaseModel):
+    """Application settings loaded from config file."""
+
+    model_config = ConfigDict(extra="ignore")
+
     # OpenAI API Configuration
     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
-    
+
     # Server Configuration
     host: str = "0.0.0.0"
     port: int = 8080
     request_timeout: float = 300.0  # 5 minutes
-    
+
     # API Key for authenticating requests to this server (optional)
     api_key: Optional[str] = None
-    
+
     # CORS settings
     cors_origins: list[str] = ["*"]
     cors_credentials: bool = True
     cors_methods: list[str] = ["*"]
     cors_headers: list[str] = ["*"]
-    
+
     # Logging
-    log_level: str = "DEBUG"
+    log_level: str = "INFO"
+    log_dir: str = ""  # Empty means use platform-specific default
 
     # Tavily Web Search Configuration
     tavily_api_key: Optional[str] = None
@@ -60,8 +153,29 @@ class Settings(BaseSettings):
             headers["OpenAI-Project"] = self.openai_project_id
         return headers
 
+    @classmethod
+    def from_toml(cls) -> "Settings":
+        """Load settings from TOML config file.
+
+        Returns:
+            Settings instance populated from config file
+        """
+        config_data = load_config_from_file()
+        return cls(**config_data)
+
 
 @lru_cache
 def get_settings() -> Settings:
-    """Get cached settings instance."""
-    return Settings()
+    """Get cached settings instance.
+
+    Creates default config file if it doesn't exist and notifies the user.
+
+    Returns:
+        Settings instance loaded from config file
+    """
+    created = create_default_config()
+    if created:
+        config_file = get_config_file()
+        print(f"Created default config file: {config_file}")
+        print("Please edit it to add your API keys and settings.")
+    return Settings.from_toml()

local_openai2anthropic/converter.py

@@ -17,13 +17,11 @@ from anthropic.types import (
 from anthropic.types.message_create_params import MessageCreateParams
 from openai.types.chat import (
     ChatCompletion,
-    ChatCompletionChunk,
     ChatCompletionToolParam,
 )
 from openai.types.chat.completion_create_params import CompletionCreateParams
 
 from local_openai2anthropic.protocol import UsageWithCache
-from local_openai2anthropic.server_tools import ServerToolRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -49,11 +47,12 @@ def convert_anthropic_to_openai(
     system = anthropic_params.get("system")
     stop_sequences = anthropic_params.get("stop_sequences")
     stream = anthropic_params.get("stream", False)
-    temperature = anthropic_params.get("temperature")
+    temperature = anthropic_params.get("temperature", 0.6)
     tool_choice = anthropic_params.get("tool_choice")
     tools = anthropic_params.get("tools")
     top_k = anthropic_params.get("top_k")
-    top_p = anthropic_params.get("top_p")
+    top_p = anthropic_params.get("top_p", 0.95)
+    repetition_penalty = anthropic_params.get("repetition_penalty", 1.1)
     thinking = anthropic_params.get("thinking")
     # metadata is accepted but not forwarded to OpenAI
 
@@ -92,7 +91,9 @@ def convert_anthropic_to_openai(
             converted_messages = _convert_anthropic_message_to_openai(msg)
             openai_messages.extend(converted_messages)
             msg_count += 1
-    logger.debug(f"Converted {msg_count} messages, total OpenAI messages: {len(openai_messages)}")
+    logger.debug(
+        f"Converted {msg_count} messages, total OpenAI messages: {len(openai_messages)}"
+    )
 
     # Build OpenAI params
     params: dict[str, Any] = {
@@ -100,6 +101,7 @@ def convert_anthropic_to_openai(
         "messages": openai_messages,
         "max_tokens": max_tokens,
         "stream": stream,
+        "repetition_penalty": repetition_penalty,
     }
 
     # Always include usage in stream for accurate token counting
@@ -139,17 +141,21 @@ def convert_anthropic_to_openai(
             openai_tools.append(openai_tool)
 
         # Add server tools as OpenAI function tools
-        for tool_class in (enabled_server_tools or []):
+        for tool_class in enabled_server_tools or []:
             if tool_class.tool_type in server_tools_config:
                 config = server_tools_config[tool_class.tool_type]
                 openai_tools.append(tool_class.to_openai_tool(config))
 
         if openai_tools:
             params["tools"] = openai_tools
-        
+
         # Convert tool_choice
         if tool_choice:
-            tc = tool_choice if isinstance(tool_choice, dict) else tool_choice.model_dump()
+            tc = (
+                tool_choice
+                if isinstance(tool_choice, dict)
+                else tool_choice.model_dump()
+            )
             tc_type = tc.get("type")
             if tc_type == "auto":
                 params["tool_choice"] = "auto"
@@ -162,7 +168,7 @@ def convert_anthropic_to_openai(
                 }
         else:
             params["tool_choice"] = "auto"
-    
+
     # 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
@@ -181,7 +187,7 @@ def convert_anthropic_to_openai(
                 logger.debug(
                     "thinking.budget_tokens (%s) is accepted but not supported by "
                     "vLLM/SGLang. Using default thinking configuration.",
-                    budget_tokens
+                    budget_tokens,
                 )
         else:
             # Default to disabled thinking mode if not explicitly enabled
@@ -208,32 +214,32 @@ def _convert_anthropic_message_to_openai(
 ) -> list[dict[str, Any]]:
     """
     Convert a single Anthropic message to OpenAI format.
-    
-    Returns a list of messages because tool_results need to be 
+
+    Returns a list of messages because tool_results need to be
     separate tool messages in OpenAI format.
     """
     role = msg.get("role", "user")
     content = msg.get("content", "")
-    
+
     if isinstance(content, str):
         return [{"role": role, "content": content}]
-    
+
     # Handle list of content blocks
     openai_content: list[dict[str, Any]] = []
     tool_calls: list[dict[str, Any]] = []
     tool_call_results: list[dict[str, Any]] = []
-    
+
     for block in content:
         if isinstance(block, str):
             openai_content.append({"type": "text", "text": block})
             continue
-            
+
         block_type = block.get("type") if isinstance(block, dict) else block.type
-        
+
         if block_type == "text":
             text = block.get("text") if isinstance(block, dict) else block.text
             openai_content.append({"type": "text", "text": text})
-            
+
         elif block_type == "image":
             # Convert image to image_url format
             source = block.get("source") if isinstance(block, dict) else block.source
@@ -246,11 +252,13 @@ def _convert_anthropic_message_to_openai(
                     data = source.data
                 # Build data URL
                 url = f"data:{media_type};base64,{data}"
-                openai_content.append({
-                    "type": "image_url",
-                    "image_url": {"url": url},
-                })
-                
+                openai_content.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": url},
+                    }
+                )
+
         elif block_type == "tool_use":
             # Convert to function call
             if isinstance(block, dict):
@@ -261,27 +269,31 @@ def _convert_anthropic_message_to_openai(
                 tool_id = block.id
                 name = block.name
                 input_data = block.input
-                
-            tool_calls.append({
-                "id": tool_id,
-                "type": "function",
-                "function": {
-                    "name": name,
-                    "arguments": json.dumps(input_data) if isinstance(input_data, dict) else str(input_data),
-                },
-            })
-            
+
+            tool_calls.append(
+                {
+                    "id": tool_id,
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "arguments": json.dumps(input_data)
+                        if isinstance(input_data, dict)
+                        else str(input_data),
+                    },
+                }
+            )
+
         elif block_type == "tool_result":
             # Tool results need to be separate tool messages
             if isinstance(block, dict):
                 tool_use_id = block.get("tool_use_id", "")
                 result_content = block.get("content", "")
-                is_error = block.get("is_error", False)
+                # Note: is_error is not directly supported in OpenAI API
             else:
                 tool_use_id = block.tool_use_id
                 result_content = block.content
-                is_error = getattr(block, "is_error", False)
-                
+                # Note: is_error is not directly supported in OpenAI API
+
             # Handle content that might be a list or string
             if isinstance(result_content, list):
                 # Extract text from content blocks
@@ -298,7 +310,7 @@ def _convert_anthropic_message_to_openai(
                 result_text = "\n".join(text_parts)
             else:
                 result_text = str(result_content)
-                
+
             tool_msg: dict[str, Any] = {
                 "role": "tool",
                 "tool_call_id": tool_use_id,
@@ -306,28 +318,28 @@ def _convert_anthropic_message_to_openai(
             }
             # Note: is_error is not directly supported in OpenAI API
             # but we could add it to content if needed
-            
+
             tool_call_results.append(tool_msg)
-    
+
     # Build primary message
     messages: list[dict[str, Any]] = []
     # SGLang requires content field to be present, default to empty string
     primary_msg: dict[str, Any] = {"role": role, "content": ""}
-    
+
     if openai_content:
         if len(openai_content) == 1 and openai_content[0]["type"] == "text":
             primary_msg["content"] = openai_content[0]["text"]
         else:
             primary_msg["content"] = openai_content
-    
+
     if tool_calls:
         primary_msg["tool_calls"] = tool_calls
-    
+
     messages.append(primary_msg)
-    
+
     # Add tool result messages separately
     messages.extend(tool_call_results)
-        
+
     return messages
 
 
@@ -353,24 +365,24 @@ def convert_openai_to_anthropic(
 ) -> Message:
     """
     Convert OpenAI ChatCompletion to Anthropic Message.
-    
+
     Args:
         completion: OpenAI chat completion response
         model: Model name
-        
+
     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)
+    reasoning_content = getattr(message, "reasoning_content", None)
     if reasoning_content:
         content.append(
             BetaThinkingBlock(
@@ -379,7 +391,7 @@ def convert_openai_to_anthropic(
                 signature="",  # Signature not available from OpenAI format
             )
         )
-    
+
     # Add text content if present
     if message.content:
         if isinstance(message.content, str):
@@ -388,16 +400,20 @@ def convert_openai_to_anthropic(
             for part in message.content:
                 if part.type == "text":
                     content.append(TextBlock(type="text", text=part.text))
-    
+
     # Convert tool calls
     if message.tool_calls:
         for tc in message.tool_calls:
+            # Handle case where function might be None
+            if not tc.function:
+                continue
+
             tool_input: dict[str, Any] = {}
             try:
                 tool_input = json.loads(tc.function.arguments)
             except json.JSONDecodeError:
                 tool_input = {"raw": tc.function.arguments}
-                
+
             content.append(
                 ToolUseBlock(
                     type="tool_use",
@@ -406,7 +422,7 @@ def convert_openai_to_anthropic(
                     input=tool_input,
                 )
             )
-    
+
     # Determine stop reason
     stop_reason_map = {
         "stop": "end_turn",
@@ -414,18 +430,24 @@ def convert_openai_to_anthropic(
         "tool_calls": "tool_use",
         "content_filter": "end_turn",
     }
-    anthropic_stop_reason = stop_reason_map.get(choice.finish_reason or "stop", "end_turn")
-    
+    anthropic_stop_reason = stop_reason_map.get(
+        choice.finish_reason or "stop", "end_turn"
+    )
+
     # Build usage dict with cache support (if available from upstream)
     usage_dict = None
     if completion.usage:
         usage_dict = {
             "input_tokens": completion.usage.prompt_tokens,
             "output_tokens": completion.usage.completion_tokens,
-            "cache_creation_input_tokens": getattr(completion.usage, "cache_creation_input_tokens", None),
-            "cache_read_input_tokens": getattr(completion.usage, "cache_read_input_tokens", None),
+            "cache_creation_input_tokens": getattr(
+                completion.usage, "cache_creation_input_tokens", None
+            ),
+            "cache_read_input_tokens": getattr(
+                completion.usage, "cache_read_input_tokens", None
+            ),
         }
-    
+
     # Build message dict to avoid Pydantic validation issues
     message_dict = {
         "id": completion.id,
@@ -437,5 +459,5 @@ def convert_openai_to_anthropic(
         "stop_sequence": None,
         "usage": usage_dict,
     }
-    
+
     return Message.model_validate(message_dict)

local_openai2anthropic/main.py

@@ -5,34 +5,103 @@ Main entry point for the local-openai2anthropic proxy server.
 
 import argparse
 import logging
+import os
 import sys
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
 
 import uvicorn
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 
-from local_openai2anthropic.config import Settings, get_settings
+from local_openai2anthropic.config import Settings, get_config_file, get_settings
 from local_openai2anthropic.protocol import AnthropicError, AnthropicErrorResponse
 from local_openai2anthropic.router import router
 
 
+def get_default_log_dir() -> str:
+    """Get default log directory based on platform.
+
+    Returns:
+        Path to log directory
+    """
+    if sys.platform == 'win32':
+        # Windows: use %LOCALAPPDATA%\local-openai2anthropic\logs
+        base_dir = os.environ.get('LOCALAPPDATA', os.path.expanduser('~\\AppData\\Local'))
+        return os.path.join(base_dir, 'local-openai2anthropic', 'logs')
+    else:
+        # macOS/Linux: use ~/.local/share/local-openai2anthropic/logs
+        return os.path.expanduser("~/.local/share/local-openai2anthropic/logs")
+
+
+def setup_logging(log_level: str, log_dir: str | None = None) -> None:
+    """Setup logging with daily rotation, keeping only today's logs.
+
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        log_dir: Directory for log files (platform-specific default)
+    """
+    # Default log directory based on platform
+    if log_dir is None:
+        log_dir = get_default_log_dir()
+
+    # Expand user directory if specified
+    log_dir = os.path.expanduser(log_dir)
+
+    # Create log directory if it doesn't exist
+    Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+    log_file = os.path.join(log_dir, "server.log")
+
+    # Create formatter
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    # Setup root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, log_level.upper()))
+
+    # Clear existing handlers
+    root_logger.handlers = []
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+
+    # File handler with daily rotation
+    # backupCount=0 means no backup files are kept (only today's log)
+    # when='midnight' rotates at midnight
+    file_handler = TimedRotatingFileHandler(
+        log_file,
+        when='midnight',
+        interval=1,
+        backupCount=0,  # Keep only today's log
+        encoding='utf-8'
+    )
+    file_handler.setFormatter(formatter)
+    root_logger.addHandler(file_handler)
+
+    logging.info(f"Logging configured. Log file: {log_file}")
+
+
 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",
-    )
+    # Configure logging with daily rotation
+    # Use platform-specific default if log_dir is not set
+    log_dir = settings.log_dir if settings.log_dir else None
+    setup_logging(settings.log_level, log_dir)
 
     # Create FastAPI app
     app = FastAPI(
         title="local-openai2anthropic",
         description="A proxy server that converts Anthropic Messages API to OpenAI API",
-        version="0.2.0",
+        version="0.3.6",
         docs_url="/docs",
         redoc_url="/redoc",
     )
@@ -134,11 +203,13 @@ def run_foreground(settings: Settings) -> None:
     """Run server in foreground mode (blocking)."""
     # Validate required settings
     if not settings.openai_api_key:
+        config_file = get_config_file()
         print(
-            "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 OA2A_OPENAI_API_KEY=your-key",
+            f"Error: openai_api_key is required.\n"
+            f"Please edit the configuration file:\n"
+            f"  {config_file}\n"
+            f"\nSet your OpenAI API key:\n"
+            f'  openai_api_key = "your-api-key"',
             file=sys.stderr,
         )
         sys.exit(1)
@@ -182,7 +253,7 @@ Examples:
     parser.add_argument(
         "--version",
         action="version",
-        version="%(prog)s 0.2.0",
+        version="%(prog)s 0.3.6",
     )
 
     # Create subparsers for commands

local_openai2anthropic/protocol.py

@@ -6,7 +6,7 @@ Uses Anthropic SDK types for request/response models.
 
 from typing import Any, Literal, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 # Re-export all Anthropic types for convenience
 from anthropic.types import (