letta-nightly 0.6.9.dev20250120104049__tar.gz → 0.6.11.dev20250120212046__tar.gz

{letta_nightly-0.6.9.dev20250120104049 → letta_nightly-0.6.11.dev20250120212046}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.9.dev20250120104049
+Version: 0.6.11.dev20250120212046
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
+Provides-Extra: bedrock
 Provides-Extra: cloud-tool-sandbox
 Provides-Extra: dev
 Provides-Extra: external-tools
@@ -20,9 +21,11 @@ Provides-Extra: qdrant
 Provides-Extra: server
 Provides-Extra: tests
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
+Requires-Dist: anthropic (>=0.43.0,<0.44.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: brotli (>=1.1.0,<2.0.0)
+Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.6.15,<0.7.0)
 Requires-Dist: composio-langchain (>=0.6.15,<0.7.0)
 Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "all"
@@ -38,10 +41,10 @@ Requires-Dist: html2text (>=2020.1.16,<2021.0.0)
 Requires-Dist: httpx (>=0.28.0,<0.29.0)
 Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
 Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
-Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
-Requires-Dist: letta_client (>=0.1.15,<0.2.0)
+Requires-Dist: letta_client (>=0.1.16,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "all"
@@ -62,20 +65,20 @@ Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pytest-order (>=1.2.0,<2.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: python-box (>=7.1.1,<8.0.0)
-Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
+Requires-Dist: python-multipart (>=0.0.19,<0.0.20)
 Requires-Dist: pytz (>=2023.3.post1,<2024.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: qdrant-client (>=1.9.1,<2.0.0) ; extra == "qdrant"
 Requires-Dist: questionary (>=2.0.1,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: sentry-sdk[fastapi] (==2.19.1)
-Requires-Dist: setuptools (>=68.2.2,<69.0.0)
+Requires-Dist: setuptools (>=70,<71)
 Requires-Dist: sqlalchemy (>=2.0.25,<3.0.0)
 Requires-Dist: sqlalchemy-json (>=0.7.0,<0.8.0)
 Requires-Dist: sqlalchemy-utils (>=0.41.2,<0.42.0)
 Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: typer (>=0.12,<1.0)
 Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server" or extra == "all"
 Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server" or extra == "all"
 Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests" or extra == "all"

{letta_nightly-0.6.9.dev20250120104049 → letta_nightly-0.6.11.dev20250120212046}/letta/__init__.py

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

{letta_nightly-0.6.9.dev20250120104049 → letta_nightly-0.6.11.dev20250120212046}/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_nightly-0.6.9.dev20250120104049 → letta_nightly-0.6.11.dev20250120212046}/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_nightly-0.6.9.dev20250120104049 → letta_nightly-0.6.11.dev20250120212046}/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_nightly-0.6.11.dev20250120212046/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