letta-nightly 0.6.9.dev20250119103943__py3-none-any.whl → 0.6.10.dev20250120193553__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.9"
+__version__ = "0.6.10"
 
 
 # import clients

letta/agent.py

@@ -1,4 +1,3 @@
-import inspect
 import json
 import time
 import traceback
@@ -20,6 +19,7 @@ from letta.constants import (
     REQ_HEARTBEAT_MESSAGE,
 )
 from letta.errors import ContextWindowExceededError
+from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.functions import get_function_from_module
 from letta.helpers import ToolRulesSolver
 from letta.interface import AgentInterface
@@ -49,6 +49,8 @@ from letta.services.helpers.agent_manager_helper import check_supports_structure
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.provider_manager import ProviderManager
+from letta.services.step_manager import StepManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
@@ -130,8 +132,10 @@ class Agent(BaseAgent):
         # Create the persistence manager object based on the AgentState info
         self.message_manager = MessageManager()
         self.passage_manager = PassageManager()
+        self.provider_manager = ProviderManager()
         self.agent_manager = AgentManager()
         self.job_manager = JobManager()
+        self.step_manager = StepManager()
 
         # State needed for heartbeat pausing
 
@@ -223,15 +227,10 @@ class Agent(BaseAgent):
                 function_response = callable_func(**function_args)
                 self.update_memory_if_changed(agent_state_copy.memory)
             else:
-                # TODO: Get rid of this. This whole piece is pretty shady, that we exec the function to just get the type hints for args.
-                env = {}
-                env.update(globals())
-                exec(target_letta_tool.source_code, env)
-                callable_func = env[target_letta_tool.json_schema["name"]]
-                spec = inspect.getfullargspec(callable_func).annotations
-                for name, arg in function_args.items():
-                    if isinstance(function_args[name], dict):
-                        function_args[name] = spec[name](**function_args[name])
+                # Parse the source code to extract function annotations
+                annotations = get_function_annotations_from_source(target_letta_tool.source_code, function_name)
+                # Coerce the function arguments to the correct types based on the annotations
+                function_args = coerce_dict_args_by_annotations(function_args, annotations)
 
                 # execute tool in a sandbox
                 # TODO: allow agent_state to specify which sandbox to execute tools in
@@ -355,7 +354,7 @@ class Agent(BaseAgent):
             if response_message.tool_calls is not None and len(response_message.tool_calls) > 1:
                 # raise NotImplementedError(f">1 tool call not supported")
                 # TODO eventually support sequential tool calling
-                printd(f">1 tool call not supported, using index=0 only\n{response_message.tool_calls}")
+                self.logger.warning(f">1 tool call not supported, using index=0 only\n{response_message.tool_calls}")
                 response_message.tool_calls = [response_message.tool_calls[0]]
             assert response_message.tool_calls is not None and len(response_message.tool_calls) > 0
 
@@ -384,7 +383,7 @@ class Agent(BaseAgent):
                     openai_message_dict=response_message.model_dump(),
                 )
             )  # extend conversation with assistant's reply
-            printd(f"Function call message: {messages[-1]}")
+            self.logger.info(f"Function call message: {messages[-1]}")
 
             nonnull_content = False
             if response_message.content:
@@ -401,7 +400,7 @@ class Agent(BaseAgent):
 
             # Get the name of the function
             function_name = function_call.name
-            printd(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
+            self.logger.info(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
 
             # Failure case 1: function name is wrong (not in agent_state.tools)
             target_letta_tool = None
@@ -467,7 +466,7 @@ class Agent(BaseAgent):
                 heartbeat_request = True
 
             if not isinstance(heartbeat_request, bool) or heartbeat_request is None:
-                printd(
+                self.logger.warning(
                     f"{CLI_WARNING_PREFIX}'request_heartbeat' arg parsed was not a bool or None, type={type(heartbeat_request)}, value={heartbeat_request}"
                 )
                 heartbeat_request = False
@@ -503,7 +502,7 @@ class Agent(BaseAgent):
                 # Less detailed - don't provide full args, idea is that it should be in recent context so no need (just adds noise)
                 error_msg = get_friendly_error_msg(function_name=function_name, exception_name=type(e).__name__, exception_message=str(e))
                 error_msg_user = f"{error_msg}\n{traceback.format_exc()}"
-                printd(error_msg_user)
+                self.logger.error(error_msg_user)
                 function_response = package_function_response(False, error_msg)
                 self.last_function_response = function_response
                 # TODO: truncate error message somehow
@@ -630,10 +629,10 @@ class Agent(BaseAgent):
 
             # Chain stops
             if not chaining:
-                printd("No chaining, stopping after one step")
+                self.logger.info("No chaining, stopping after one step")
                 break
             elif max_chaining_steps is not None and counter > max_chaining_steps:
-                printd(f"Hit max chaining steps, stopping after {counter} steps")
+                self.logger.info(f"Hit max chaining steps, stopping after {counter} steps")
                 break
             # Chain handlers
             elif token_warning:
@@ -713,7 +712,7 @@ class Agent(BaseAgent):
             input_message_sequence = in_context_messages + messages
 
             if len(input_message_sequence) > 1 and input_message_sequence[-1].role != "user":
-                printd(f"{CLI_WARNING_PREFIX}Attempting to run ChatCompletion without user as the last message in the queue")
+                self.logger.warning(f"{CLI_WARNING_PREFIX}Attempting to run ChatCompletion without user as the last message in the queue")
 
             # Step 2: send the conversation and available functions to the LLM
             response = self._get_ai_reply(
@@ -755,7 +754,7 @@ class Agent(BaseAgent):
                 )
 
             if current_total_tokens > MESSAGE_SUMMARY_WARNING_FRAC * int(self.agent_state.llm_config.context_window):
-                printd(
+                self.logger.warning(
                     f"{CLI_WARNING_PREFIX}last response total_tokens ({current_total_tokens}) > {MESSAGE_SUMMARY_WARNING_FRAC * int(self.agent_state.llm_config.context_window)}"
                 )
 
@@ -765,10 +764,28 @@ class Agent(BaseAgent):
                     self.agent_alerted_about_memory_pressure = True  # it's up to the outer loop to handle this
 
             else:
-                printd(
+                self.logger.warning(
                     f"last response total_tokens ({current_total_tokens}) < {MESSAGE_SUMMARY_WARNING_FRAC * int(self.agent_state.llm_config.context_window)}"
                 )
 
+            # Log step - this must happen before messages are persisted
+            step = self.step_manager.log_step(
+                actor=self.user,
+                provider_name=self.agent_state.llm_config.model_endpoint_type,
+                model=self.agent_state.llm_config.model,
+                context_window_limit=self.agent_state.llm_config.context_window,
+                usage=response.usage,
+                # TODO(@caren): Add full provider support - this line is a workaround for v0 BYOK feature
+                provider_id=(
+                    self.provider_manager.get_anthropic_override_provider_id()
+                    if self.agent_state.llm_config.model_endpoint_type == "anthropic"
+                    else None
+                ),
+                job_id=job_id,
+            )
+            for message in all_new_messages:
+                message.step_id = step.id
+
             # Persisting into Messages
             self.agent_state = self.agent_manager.append_to_in_context_messages(
                 all_new_messages, agent_id=self.agent_state.id, actor=self.user
@@ -790,11 +807,11 @@ class Agent(BaseAgent):
             )
 
         except Exception as e:
-            printd(f"step() failed\nmessages = {messages}\nerror = {e}")
+            self.logger.error(f"step() failed\nmessages = {messages}\nerror = {e}")
 
             # If we got a context alert, try trimming the messages length, then try again
             if is_context_overflow_error(e):
-                printd(
+                self.logger.warning(
                     f"context window exceeded with limit {self.agent_state.llm_config.context_window}, running summarizer to trim messages"
                 )
                 # A separate API call to run a summarizer
@@ -811,7 +828,7 @@ class Agent(BaseAgent):
                 )
 
             else:
-                printd(f"step() failed with an unrecognized exception: '{str(e)}'")
+                self.logger.error(f"step() failed with an unrecognized exception: '{str(e)}'")
                 raise e
 
     def step_user_message(self, user_message_str: str, **kwargs) -> AgentStepResponse:

letta/client/client.py

@@ -410,7 +410,8 @@ class RESTClient(AbstractClient):
     def __init__(
         self,
         base_url: str,
-        token: str,
+        token: Optional[str] = None,
+        password: Optional[str] = None,
         api_prefix: str = "v1",
         debug: bool = False,
         default_llm_config: Optional[LLMConfig] = None,
@@ -426,11 +427,18 @@ class RESTClient(AbstractClient):
             default_llm_config (Optional[LLMConfig]): The default LLM configuration.
             default_embedding_config (Optional[EmbeddingConfig]): The default embedding configuration.
             headers (Optional[Dict]): The additional headers for the REST API.
+            token (Optional[str]): The token for the REST API when using managed letta service.
+            password (Optional[str]): The password for the REST API when using self hosted letta service.
         """
         super().__init__(debug=debug)
         self.base_url = base_url
         self.api_prefix = api_prefix
-        self.headers = {"accept": "application/json", "authorization": f"Bearer {token}"}
+        if token:
+            self.headers = {"accept": "application/json", "Authorization": f"Bearer {token}"}
+        elif password:
+            self.headers = {"accept": "application/json", "X-BARE-PASSWORD": f"password {password}"}
+        else:
+            self.headers = {"accept": "application/json"}
         if headers:
             self.headers.update(headers)
         self._default_llm_config = default_llm_config

letta/errors.py

@@ -62,6 +62,20 @@ class LLMError(LettaError):
     pass
 
 
+class BedrockPermissionError(LettaError):
+    """Exception raised for errors in the Bedrock permission process."""
+
+    def __init__(self, message="User does not have access to the Bedrock model with the specified ID."):
+        super().__init__(message=message)
+
+
+class BedrockError(LettaError):
+    """Exception raised for errors in the Bedrock process."""
+
+    def __init__(self, message="Error with Bedrock model."):
+        super().__init__(message=message)
+
+
 class LLMJSONParsingError(LettaError):
     """Exception raised for errors in the JSON parsing process."""
 

letta/functions/ast_parsers.py

@@ -0,0 +1,105 @@
+import ast
+import json
+from typing import Dict
+
+# Registry of known types for annotation resolution
+BUILTIN_TYPES = {
+    "int": int,
+    "float": float,
+    "str": str,
+    "dict": dict,
+    "list": list,
+    "set": set,
+    "tuple": tuple,
+    "bool": bool,
+}
+
+
+def resolve_type(annotation: str):
+    """
+    Resolve a type annotation string into a Python type.
+
+    Args:
+        annotation (str): The annotation string (e.g., 'int', 'list', etc.).
+
+    Returns:
+        type: The corresponding Python type.
+
+    Raises:
+        ValueError: If the annotation is unsupported or invalid.
+    """
+    if annotation in BUILTIN_TYPES:
+        return BUILTIN_TYPES[annotation]
+
+    try:
+        parsed = ast.literal_eval(annotation)
+        if isinstance(parsed, type):
+            return parsed
+        raise ValueError(f"Annotation '{annotation}' is not a recognized type.")
+    except (ValueError, SyntaxError):
+        raise ValueError(f"Unsupported annotation: {annotation}")
+
+
+def get_function_annotations_from_source(source_code: str, function_name: str) -> Dict[str, str]:
+    """
+    Parse the source code to extract annotations for a given function name.
+
+    Args:
+        source_code (str): The Python source code containing the function.
+        function_name (str): The name of the function to extract annotations for.
+
+    Returns:
+        Dict[str, str]: A dictionary of argument names to their annotation strings.
+
+    Raises:
+        ValueError: If the function is not found in the source code.
+    """
+    tree = ast.parse(source_code)
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == function_name:
+            annotations = {}
+            for arg in node.args.args:
+                if arg.annotation is not None:
+                    annotation_str = ast.unparse(arg.annotation)
+                    annotations[arg.arg] = annotation_str
+            return annotations
+    raise ValueError(f"Function '{function_name}' not found in the provided source code.")
+
+
+def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str, str]) -> dict:
+    """
+    Coerce arguments in a dictionary to their annotated types.
+
+    Args:
+        function_args (dict): The original function arguments.
+        annotations (Dict[str, str]): Argument annotations as strings.
+
+    Returns:
+        dict: The updated dictionary with coerced argument types.
+
+    Raises:
+        ValueError: If type coercion fails for an argument.
+    """
+    coerced_args = dict(function_args)  # Shallow copy for mutation safety
+
+    for arg_name, value in coerced_args.items():
+        if arg_name in annotations:
+            annotation_str = annotations[arg_name]
+            try:
+                # Resolve the type from the annotation
+                arg_type = resolve_type(annotation_str)
+
+                # Handle JSON-like inputs for dict and list types
+                if arg_type in {dict, list} and isinstance(value, str):
+                    try:
+                        # First, try JSON parsing
+                        value = json.loads(value)
+                    except json.JSONDecodeError:
+                        # Fall back to literal_eval for Python-specific literals
+                        value = ast.literal_eval(value)
+
+                # Coerce the value to the resolved type
+                coerced_args[arg_name] = arg_type(value)
+            except (TypeError, ValueError, json.JSONDecodeError, SyntaxError) as e:
+                raise ValueError(f"Failed to coerce argument '{arg_name}' to {annotation_str}: {e}")
+    return coerced_args

letta/llm_api/anthropic.py

@@ -1,8 +1,12 @@
 import json
 import re
-from typing import List, Optional, Union
+from typing import List, Optional, Tuple, Union
 
-from letta.llm_api.helpers import make_post_request
+import anthropic
+from anthropic import PermissionDeniedError
+
+from letta.errors import BedrockError, BedrockPermissionError
+from letta.llm_api.aws_bedrock import get_bedrock_client
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall
@@ -10,6 +14,8 @@ from letta.schemas.openai.chat_completion_response import (
     Message as ChoiceMessage,  # NOTE: avoid conflict with our own Letta Message datatype
 )
 from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
+from letta.services.provider_manager import ProviderManager
+from letta.settings import model_settings
 from letta.utils import get_utc_time, smart_urljoin
 
 BASE_URL = "https://api.anthropic.com/v1"
@@ -195,7 +201,7 @@ def strip_xml_tags(string: str, tag: Optional[str]) -> str:
 
 
 def convert_anthropic_response_to_chatcompletion(
-    response_json: dict,  # REST response from Google AI API
+    response: anthropic.types.Message,
     inner_thoughts_xml_tag: Optional[str] = None,
 ) -> ChatCompletionResponse:
     """
@@ -232,65 +238,67 @@ def convert_anthropic_response_to_chatcompletion(
         }
     }
     """
-    prompt_tokens = response_json["usage"]["input_tokens"]
-    completion_tokens = response_json["usage"]["output_tokens"]
-
-    finish_reason = remap_finish_reason(response_json["stop_reason"])
-
-    if isinstance(response_json["content"], list):
-        if len(response_json["content"]) > 1:
-            # inner mono + function call
-            assert len(response_json["content"]) == 2, response_json
-            assert response_json["content"][0]["type"] == "text", response_json
-            assert response_json["content"][1]["type"] == "tool_use", response_json
-            content = strip_xml_tags(string=response_json["content"][0]["text"], tag=inner_thoughts_xml_tag)
+    prompt_tokens = response.usage.input_tokens
+    completion_tokens = response.usage.output_tokens
+    finish_reason = remap_finish_reason(response.stop_reason)
+
+    content = None
+    tool_calls = None
+
+    if len(response.content) > 1:
+        # inner mono + function call
+        assert len(response.content) == 2
+        text_block = response.content[0]
+        tool_block = response.content[1]
+        assert text_block.type == "text"
+        assert tool_block.type == "tool_use"
+        content = strip_xml_tags(string=text_block.text, tag=inner_thoughts_xml_tag)
+        tool_calls = [
+            ToolCall(
+                id=tool_block.id,
+                type="function",
+                function=FunctionCall(
+                    name=tool_block.name,
+                    arguments=json.dumps(tool_block.input, indent=2),
+                ),
+            )
+        ]
+    elif len(response.content) == 1:
+        block = response.content[0]
+        if block.type == "tool_use":
+            # function call only
             tool_calls = [
                 ToolCall(
-                    id=response_json["content"][1]["id"],
+                    id=block.id,
                     type="function",
                     function=FunctionCall(
-                        name=response_json["content"][1]["name"],
-                        arguments=json.dumps(response_json["content"][1]["input"], indent=2),
+                        name=block.name,
+                        arguments=json.dumps(block.input, indent=2),
                     ),
                 )
             ]
-        elif len(response_json["content"]) == 1:
-            if response_json["content"][0]["type"] == "tool_use":
-                # function call only
-                content = None
-                tool_calls = [
-                    ToolCall(
-                        id=response_json["content"][0]["id"],
-                        type="function",
-                        function=FunctionCall(
-                            name=response_json["content"][0]["name"],
-                            arguments=json.dumps(response_json["content"][0]["input"], indent=2),
-                        ),
-                    )
-                ]
-            else:
-                # inner mono only
-                content = strip_xml_tags(string=response_json["content"][0]["text"], tag=inner_thoughts_xml_tag)
-                tool_calls = None
+        else:
+            # inner mono only
+            content = strip_xml_tags(string=block.text, tag=inner_thoughts_xml_tag)
     else:
-        raise RuntimeError("Unexpected type for content in response_json.")
+        raise RuntimeError("Unexpected empty content in response")
 
-    assert response_json["role"] == "assistant", response_json
+    assert response.role == "assistant"
     choice = Choice(
         index=0,
         finish_reason=finish_reason,
         message=ChoiceMessage(
-            role=response_json["role"],
+            role=response.role,
             content=content,
             tool_calls=tool_calls,
         ),
     )
 
     return ChatCompletionResponse(
-        id=response_json["id"],
+        id=response.id,
         choices=[choice],
         created=get_utc_time(),
-        model=response_json["model"],
+        model=response.model,
         usage=UsageStatistics(
             prompt_tokens=prompt_tokens,
             completion_tokens=completion_tokens,
@@ -299,23 +307,11 @@ def convert_anthropic_response_to_chatcompletion(
     )
 
 
-def anthropic_chat_completions_request(
-    url: str,
-    api_key: str,
+def _prepare_anthropic_request(
     data: ChatCompletionRequest,
     inner_thoughts_xml_tag: Optional[str] = "thinking",
-) -> ChatCompletionResponse:
-    """https://docs.anthropic.com/claude/docs/tool-use"""
-
-    url = smart_urljoin(url, "messages")
-    headers = {
-        "Content-Type": "application/json",
-        "x-api-key": api_key,
-        # NOTE: beta headers for tool calling
-        "anthropic-version": "2023-06-01",
-        "anthropic-beta": "tools-2024-04-04",
-    }
-
+) -> dict:
+    """Prepare the request data for Anthropic API format."""
     # convert the tools
     anthropic_tools = None if data.tools is None else convert_tools_to_anthropic_format(data.tools)
 
@@ -325,57 +321,109 @@ def anthropic_chat_completions_request(
     if "functions" in data:
         raise ValueError(f"'functions' unexpected in Anthropic API payload")
 
-    # If tools == None, strip from the payload
+    # Handle tools
     if "tools" in data and data["tools"] is None:
         data.pop("tools")
-        data.pop("tool_choice", None)  # extra safe,  should exist always (default="auto")
-    # Remap to our converted tools
-    if anthropic_tools is not None:
+        data.pop("tool_choice", None)
+    elif anthropic_tools is not None:
         data["tools"] = anthropic_tools
-
-        # TODO: Add support for other tool_choice options like "auto", "any"
         if len(anthropic_tools) == 1:
             data["tool_choice"] = {
-                "type": "tool",  # Changed from "function" to "tool"
-                "name": anthropic_tools[0]["name"],  # Directly specify name without nested "function" object
-                "disable_parallel_tool_use": True,  # Force single tool use
+                "type": "tool",
+                "name": anthropic_tools[0]["name"],
+                "disable_parallel_tool_use": True,
             }
 
     # Move 'system' to the top level
-    # 'messages: Unexpected role "system". The Messages API accepts a top-level `system` parameter, not "system" as an input message role.'
     assert data["messages"][0]["role"] == "system", f"Expected 'system' role in messages[0]:\n{data['messages'][0]}"
     data["system"] = data["messages"][0]["content"]
     data["messages"] = data["messages"][1:]
 
-    # set `content` to None if missing
+    # Process messages
     for message in data["messages"]:
         if "content" not in message:
             message["content"] = None
 
     # Convert to Anthropic format
-
     msg_objs = [Message.dict_to_message(user_id=None, agent_id=None, openai_message_dict=m) for m in data["messages"]]
     data["messages"] = [m.to_anthropic_dict(inner_thoughts_xml_tag=inner_thoughts_xml_tag) for m in msg_objs]
 
-    # Handling Anthropic special requirement for 'user' message in front
-    # messages: first message must use the "user" role'
+    # Ensure first message is user
     if data["messages"][0]["role"] != "user":
         data["messages"] = [{"role": "user", "content": DUMMY_FIRST_USER_MESSAGE}] + data["messages"]
 
-    # Handle Anthropic's restriction on alternating user/assistant messages
+    # Handle alternating messages
     data["messages"] = merge_tool_results_into_user_messages(data["messages"])
 
-    # Anthropic also wants max_tokens in the input
-    # It's also part of ChatCompletions
+    # Validate max_tokens
     assert "max_tokens" in data, data
 
-    # Remove extra fields used by OpenAI but not Anthropic
-    data.pop("frequency_penalty", None)
-    data.pop("logprobs", None)
-    data.pop("n", None)
-    data.pop("top_p", None)
-    data.pop("presence_penalty", None)
-    data.pop("user", None)
+    # Remove OpenAI-specific fields
+    for field in ["frequency_penalty", "logprobs", "n", "top_p", "presence_penalty", "user"]:
+        data.pop(field, None)
+
+    return data
+
+
+def get_anthropic_endpoint_and_headers(
+    base_url: str,
+    api_key: str,
+    version: str = "2023-06-01",
+    beta: Optional[str] = "tools-2024-04-04",
+) -> Tuple[str, dict]:
+    """
+    Dynamically generate the Anthropic endpoint and headers.
+    """
+    url = smart_urljoin(base_url, "messages")
+
+    headers = {
+        "Content-Type": "application/json",
+        "x-api-key": api_key,
+        "anthropic-version": version,
+    }
+
+    # Add beta header if specified
+    if beta:
+        headers["anthropic-beta"] = beta
+
+    return url, headers
+
+
+def anthropic_chat_completions_request(
+    data: ChatCompletionRequest,
+    inner_thoughts_xml_tag: Optional[str] = "thinking",
+    betas: List[str] = ["tools-2024-04-04"],
+) -> ChatCompletionResponse:
+    """https://docs.anthropic.com/claude/docs/tool-use"""
+    anthropic_client = None
+    anthropic_override_key = ProviderManager().get_anthropic_override_key()
+    if anthropic_override_key:
+        anthropic_client = anthropic.Anthropic(api_key=anthropic_override_key)
+    elif model_settings.anthropic_api_key:
+        anthropic_client = anthropic.Anthropic()
+    data = _prepare_anthropic_request(data, inner_thoughts_xml_tag)
+    response = anthropic_client.beta.messages.create(
+        **data,
+        betas=betas,
+    )
+    return convert_anthropic_response_to_chatcompletion(response=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
+
 
-    response_json = make_post_request(url, headers, data)
-    return convert_anthropic_response_to_chatcompletion(response_json=response_json, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
+def anthropic_bedrock_chat_completions_request(
+    data: ChatCompletionRequest,
+    inner_thoughts_xml_tag: Optional[str] = "thinking",
+) -> ChatCompletionResponse:
+    """Make a chat completion request to Anthropic via AWS Bedrock."""
+    data = _prepare_anthropic_request(data, inner_thoughts_xml_tag)
+
+    # Get the client
+    client = get_bedrock_client()
+
+    # Make the request
+    try:
+        response = client.messages.create(**data)
+        return convert_anthropic_response_to_chatcompletion(response=response, inner_thoughts_xml_tag=inner_thoughts_xml_tag)
+    except PermissionDeniedError:
+        raise BedrockPermissionError(f"User does not have access to the Bedrock model with the specified ID. {data['model']}")
+    except Exception as e:
+        raise BedrockError(f"Bedrock error: {e}")