ccproxy.claude_sdk.options

ccproxy.claude_sdk.options

Options handling for Claude SDK interactions.

OptionsHandler

OptionsHandler(settings=None)

Handles creation and management of Claude SDK options.

Parameters:

Name	Type	Description	Default
settings	Settings | None	Application settings containing default Claude options	None

Source code in ccproxy/claude_sdk/options.py

def __init__(self, settings: Settings | None = None) -> None:
    """
    Initialize options handler.

    Args:
        settings: Application settings containing default Claude options
    """
    self.settings = settings

create_options

create_options(
    model,
    temperature=None,
    max_tokens=None,
    system_message=None,
    **kwargs,
)

Create Claude SDK options from API parameters.

Parameters:

Name	Type	Description	Default
model	str	The model name	required
temperature	float | None	Temperature for response generation	None
max_tokens	int | None	Maximum tokens in response	None
system_message	str | None	System message to include	None
**kwargs	Any	Additional options	{}

Returns:

Type	Description
ClaudeCodeOptions	Configured ClaudeCodeOptions instance

Source code in ccproxy/claude_sdk/options.py

def create_options(
    self,
    model: str,
    temperature: float | None = None,
    max_tokens: int | None = None,
    system_message: str | None = None,
    **kwargs: Any,
) -> ClaudeCodeOptions:
    """
    Create Claude SDK options from API parameters.

    Args:
        model: The model name
        temperature: Temperature for response generation
        max_tokens: Maximum tokens in response
        system_message: System message to include
        **kwargs: Additional options

    Returns:
        Configured ClaudeCodeOptions instance
    """
    options = ClaudeCodeOptions(model=model)

    # First apply settings from configuration if available
    if self.settings and self.settings.claude.code_options:
        code_opts = self.settings.claude.code_options

        # Apply settings from configuration
        for attr_name in dir(code_opts):
            if not attr_name.startswith("_"):
                value = getattr(code_opts, attr_name, None)
                if value is not None and hasattr(options, attr_name):
                    setattr(options, attr_name, value)

    # Then apply API parameters (these override settings)
    if temperature is not None:
        options.temperature = temperature  # type: ignore[attr-defined]

    if max_tokens is not None:
        options.max_tokens = max_tokens  # type: ignore[attr-defined]

    if system_message is not None:
        options.system_prompt = system_message

    # Handle other options as needed
    for key, value in kwargs.items():
        if hasattr(options, key):
            setattr(options, key, value)

    return options

extract_system_message staticmethod

extract_system_message(messages)

Extract system message from Anthropic messages format.

Parameters:

Name	Type	Description	Default
messages	list[dict[str, Any]]	List of messages in Anthropic format	required

Returns:

Type	Description
str | None	System message content if found, None otherwise

Source code in ccproxy/claude_sdk/options.py

@staticmethod
def extract_system_message(messages: list[dict[str, Any]]) -> str | None:
    """
    Extract system message from Anthropic messages format.

    Args:
        messages: List of messages in Anthropic format

    Returns:
        System message content if found, None otherwise
    """
    for message in messages:
        if message.get("role") == "system":
            content = message.get("content", "")
            if isinstance(content, list):
                # Handle content blocks
                text_parts = []
                for block in content:
                    if block.get("type") == "text":
                        text_parts.append(block.get("text", ""))
                return " ".join(text_parts)
            return str(content)
    return None

get_supported_models staticmethod

get_supported_models()

Get list of supported Claude models.

Returns:

Type	Description
list[str]	List of supported model names

Source code in ccproxy/claude_sdk/options.py

@staticmethod
def get_supported_models() -> list[str]:
    """
    Get list of supported Claude models.

    Returns:
        List of supported model names
    """
    # Import here to avoid circular imports
    from ccproxy.adapters.openai.adapter import OPENAI_TO_CLAUDE_MODEL_MAPPING

    # Extract unique Claude models from OpenAI mapping
    claude_models = list(set(OPENAI_TO_CLAUDE_MODEL_MAPPING.values()))
    return sorted(claude_models)

validate_model staticmethod

validate_model(model)

Validate if a model is supported.

Parameters:

Name	Type	Description	Default
model	str	The model name to validate	required

Returns:

Type	Description
bool	True if supported, False otherwise

Source code in ccproxy/claude_sdk/options.py

@staticmethod
def validate_model(model: str) -> bool:
    """
    Validate if a model is supported.

    Args:
        model: The model name to validate

    Returns:
        True if supported, False otherwise
    """
    return model in OptionsHandler.get_supported_models()

get_default_options staticmethod

get_default_options()

Get default options for Claude SDK.

Returns:

Type	Description
dict[str, Any]	Dictionary of default options

Source code in ccproxy/claude_sdk/options.py

@staticmethod
def get_default_options() -> dict[str, Any]:
    """
    Get default options for Claude SDK.

    Returns:
        Dictionary of default options
    """
    return {
        "model": "claude-3-5-sonnet-20241022",
        "temperature": 0.7,
        "max_tokens": 4000,
    }