BedrockV2LLMConfigEntry

def create_client(self) -> ModelClient:  # pragma: no cover
    """Create BedrockV2Client instance.

    Note: This is typically handled via OpenAIWrapper._register_default_client,
    but can be called directly if needed.
    """
    # Extract credentials, handling SecretStr
    aws_access_key = self.aws_access_key.get_secret_value() if self.aws_access_key else None
    aws_secret_key = self.aws_secret_key.get_secret_value() if self.aws_secret_key else None
    aws_session_token = self.aws_session_token.get_secret_value() if self.aws_session_token else None

    # BedrockV2Client is defined later in this module, but Python resolves it at runtime
    # Using globals() to access the class defined in this module
    BedrockV2Client = globals()["BedrockV2Client"]  # noqa: N806

    return BedrockV2Client(
        aws_region=self.aws_region,
        aws_access_key=aws_access_key,
        aws_secret_key=aws_secret_key,
        aws_session_token=aws_session_token,
        aws_profile_name=self.aws_profile_name,
        timeout=self.timeout,
        total_max_attempts=self.total_max_attempts,
        max_attempts=self.max_attempts,
        mode=self.mode,
        response_format=None,  # Can be set via params in create() call
    )

def apply_application_config(self, application_config: ApplicationConfig) -> Self:
    """Apply application level configurations."""
    new_entry = self.model_copy()
    new_entry.max_tokens = new_entry.max_tokens or application_config.max_tokens
    new_entry.top_p = new_entry.top_p or application_config.top_p
    new_entry.temperature = new_entry.temperature or application_config.temperature
    return new_entry

@field_validator("base_url", mode="before")
@classmethod
def check_base_url(cls, v: HttpUrl | str | None, info: ValidationInfo) -> str | None:
    if v is None:  # Handle None case explicitly
        return None
    # Allow WebSocket URLs as well as HTTP(S)
    if not str(v).startswith(("https://", "http://", "wss://", "ws://")):
        return f"http://{str(v)}"
    return str(v)

@field_serializer("base_url", when_used="unless-none")  # Ensure serializer also respects None
def serialize_base_url(self, v: HttpUrl | None) -> str | None:
    return str(v) if v is not None else None

@field_serializer("api_key", when_used="unless-none")
def serialize_api_key(self, v: SecretStr) -> str:
    return v.get_secret_value()

def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
    return BaseModel.model_dump(self, exclude_none=exclude_none, *args, **kwargs)

def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
    return BaseModel.model_dump_json(self, exclude_none=exclude_none, *args, **kwargs)

def get(self, key: str, default: Any | None = None) -> Any:
    val = getattr(self, key, default)
    if isinstance(val, SecretStr):
        return val.get_secret_value()
    return val

def items(self) -> Iterable[tuple[str, Any]]:
    d = self.model_dump()
    return d.items()

def keys(self) -> Iterable[str]:
    d = self.model_dump()
    return d.keys()

def values(self) -> Iterable[Any]:
    d = self.model_dump()
    return d.values()

@field_serializer("aws_access_key", "aws_secret_key", "aws_session_token", when_used="unless-none")
def serialize_aws_secrets(self, v: SecretStr) -> str:
    return v.get_secret_value()