ccproxy.plugins.claude_sdk.options

ccproxy.plugins.claude_sdk.options

Options handling for Claude SDK interactions.

OptionsHandler

OptionsHandler(config)

Handles creation and management of Claude SDK options.

Parameters:

Name	Type	Description	Default
config	ClaudeSDKSettings	Plugin-specific configuration for Claude SDK	required

Source code in ccproxy/plugins/claude_sdk/options.py

def __init__(self, config: ClaudeSDKSettings) -> None:
    """
    Initialize options handler.

    Args:
        config: Plugin-specific configuration for Claude SDK
    """
    self.config = config

create_options

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

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
**additional_options	Any	Additional options to set on the ClaudeAgentOptions instance	{}

Returns:

Type	Description
ClaudeAgentOptions	Configured ClaudeAgentOptions instance

Source code in ccproxy/plugins/claude_sdk/options.py

def create_options(
    self,
    model: str,
    temperature: float | None = None,
    max_tokens: int | None = None,
    system_message: str | None = None,
    **additional_options: Any,
) -> ClaudeAgentOptions:
    """
    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
        **additional_options: Additional options to set on the ClaudeAgentOptions instance

    Returns:
        Configured ClaudeAgentOptions instance
    """
    # Start with configured defaults if available, otherwise create fresh instance
    if self.config and self.config.code_options:
        configured_opts = self.config.code_options
        options = ClaudeAgentOptions()

        # Copy all attributes from configured defaults
        for attr in dir(configured_opts):
            if not attr.startswith("_"):
                configured_value = getattr(configured_opts, attr)
                if configured_value is not None and hasattr(options, attr):
                    # Special handling for mcp_servers to ensure we copy the dict
                    if attr == "mcp_servers" and isinstance(configured_value, dict):
                        setattr(options, attr, configured_value.copy())
                    else:
                        setattr(options, attr, configured_value)
    else:
        options = ClaudeAgentOptions()

    # Override the model (API parameter takes precedence)
    options.model = model

    # Apply system message if provided (this is supported by ClaudeAgentOptions)
    if system_message is not None:
        options.system_prompt = system_message

    # If session_id is provided via additional_options, enable continue_conversation
    if additional_options.get("session_id"):
        options.continue_conversation = True

    # Automatically map additional_options to ClaudeAgentOptions attributes
    for key, value in additional_options.items():
        if hasattr(options, key):
            try:
                # Attempt type conversion if the attribute already exists
                attr_type = type(getattr(options, key))
                # Only convert if the attribute is not None
                if getattr(options, key) is not None:
                    setattr(options, key, attr_type(value))
                else:
                    setattr(options, key, value)
            except Exception:
                # Fallback to direct assignment if conversion fails
                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/plugins/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/plugins/claude_sdk/options.py

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

    Returns:
        List of supported model names
    """
    from ccproxy.plugins.claude_shared.model_defaults import (
        DEFAULT_CLAUDE_MODEL_CARDS,
    )

    return [card.id for card in DEFAULT_CLAUDE_MODEL_CARDS]

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/plugins/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 API parameters.

Returns:

Type	Description
dict[str, Any]	Dictionary of default API parameter values

Source code in ccproxy/plugins/claude_sdk/options.py

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

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