Bedrock

@staticmethod
def create_payload(
    user_message: str | list[str], max_tokens: int = 256, **kwargs: Any
) -> dict:
    """
    Create a payload for the Bedrock Converse API request.

    Args:
        user_message (str | Sequence[str]): The user's message or a sequence of messages.
        max_tokens (int, optional): The maximum number of tokens to generate. Defaults to 256.
        **kwargs: Additional keyword arguments to include in the payload.

    Returns:
        dict: The formatted payload for the Bedrock API request.

    Raises:
        TypeError: If user_message is not a string or list of strings
        ValueError: If max_tokens is not a positive integer
    """
    if not isinstance(user_message, (str, list)):
        raise TypeError("user_message must be a string or list of strings")

    if isinstance(user_message, list):
        if not all(isinstance(msg, str) for msg in user_message):
            raise TypeError("All messages must be strings")
        if not user_message:
            raise ValueError("user_message list cannot be empty")

    if not isinstance(max_tokens, int) or max_tokens <= 0:
        raise ValueError("max_tokens must be a positive integer")

    if isinstance(user_message, str):
        user_message = [user_message]

    try:
        payload: dict = {
            "messages": [
                {"role": "user", "content": [{"text": k}]} for k in user_message
            ],
        }
        payload.update(kwargs)
        if payload.get("inferenceConfig") is None:
            payload["inferenceConfig"] = {}

        payload["inferenceConfig"] = {
            **payload["inferenceConfig"],
            "maxTokens": max_tokens,
        }
        return payload

    except Exception as e:
        logger.error(f"Error creating payload: {e}")
        raise RuntimeError(f"Failed to create payload: {str(e)}")

def invoke(self, payload: dict, **kwargs: Any) -> InvocationResponse:
    """
    Invoke the Bedrock converse API with the given payload.

    Args:
        payload (dict): The payload containing the request parameters
        **kwargs: Additional keyword arguments to include in the payload

    Returns:
        InvocationResponse: Response object containing generated text and metadata

    Raises:
        ClientError: If there is an error calling the Bedrock API
        ValueError: If payload is invalid
        TypeError: If payload is not a dictionary
    """
    if not isinstance(payload, dict):
        raise TypeError("Payload must be a dictionary")

    try:
        payload = {**kwargs, **payload}
        if payload.get("inferenceConfig") is None:
            payload["inferenceConfig"] = self._inference_config or {}

        payload["modelId"] = self.model_id
        try:
            start_t = time.perf_counter()
            client_response = self._bedrock_client.converse(**payload)  # type: ignore
            time_to_last_token = time.perf_counter() - start_t
        except ClientError as e:
            logger.error(f"Bedrock API error: {e}")
            return InvocationResponse.error_output(
                input_payload=payload, id=uuid4().hex, error=str(e)
            )
        except Exception as e:
            logger.error(f"Unexpected error during API call: {e}")
            return InvocationResponse.error_output(
                input_payload=payload, id=uuid4().hex, error=str(e)
            )

        response = self._parse_converse_response(client_response)  # type: ignore
        response.input_payload = payload
        response.input_prompt = self._parse_payload(payload)
        response.time_to_last_token = time_to_last_token
        return response

    except Exception as e:
        logger.error(f"Error in invoke method: {e}")
        return InvocationResponse.error_output(
            input_payload=payload, id=uuid4().hex, error=str(e)
        )