letta-nightly 0.5.4.dev20241130104041__tar.gz → 0.5.4.dev20241204014655__tar.gz

{letta_nightly-0.5.4.dev20241130104041 → letta_nightly-0.5.4.dev20241204014655}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.4.dev20241130104041
+Version: 0.5.4.dev20241204014655
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -129,24 +129,24 @@ The two main ways to install Letta are through **pypi** (`pip`) or via **Docker*
 
 ### Step 1 - Install Letta using `pip`
 ```sh
-$ pip install -U letta
+pip install -U letta
 ```
 
 ### Step 2 - Set your environment variables for your chosen LLM / embedding providers
 ```sh
-$ export OPENAI_API_KEY=sk-...
+export OPENAI_API_KEY=sk-...
 ```
 
 For Ollama (see our full [documentation](https://docs.letta.com/install) for examples of how to set up various providers):
 ```sh
-$ export OLLAMA_BASE_URL=http://localhost:11434
+export OLLAMA_BASE_URL=http://localhost:11434
 ```
 
 ### Step 3 - Run the Letta CLI
 
 You can create agents and chat with them via the Letta CLI tool (`letta run`):
 ```sh
-$ letta run
+letta run
 ```
 ```
 🧬 Creating new agent...
@@ -179,7 +179,7 @@ Hit enter to begin (will request first Letta message)
 
 You can start the Letta API server with `letta server` (see the full API reference [here](https://docs.letta.com/api-reference)):
 ```sh
-$ letta server
+letta server
 ```
 ```
 Initializing database...

{letta_nightly-0.5.4.dev20241130104041 → letta_nightly-0.5.4.dev20241204014655}/README.md

@@ -44,24 +44,24 @@ The two main ways to install Letta are through **pypi** (`pip`) or via **Docker*
 
 ### Step 1 - Install Letta using `pip`
 ```sh
-$ pip install -U letta
+pip install -U letta
 ```
 
 ### Step 2 - Set your environment variables for your chosen LLM / embedding providers
 ```sh
-$ export OPENAI_API_KEY=sk-...
+export OPENAI_API_KEY=sk-...
 ```
 
 For Ollama (see our full [documentation](https://docs.letta.com/install) for examples of how to set up various providers):
 ```sh
-$ export OLLAMA_BASE_URL=http://localhost:11434
+export OLLAMA_BASE_URL=http://localhost:11434
 ```
 
 ### Step 3 - Run the Letta CLI
 
 You can create agents and chat with them via the Letta CLI tool (`letta run`):
 ```sh
-$ letta run
+letta run
 ```
 ```
 🧬 Creating new agent...
@@ -94,7 +94,7 @@ Hit enter to begin (will request first Letta message)
 
 You can start the Letta API server with `letta server` (see the full API reference [here](https://docs.letta.com/api-reference)):
 ```sh
-$ letta server
+letta server
 ```
 ```
 Initializing database...

{letta_nightly-0.5.4.dev20241130104041 → letta_nightly-0.5.4.dev20241204014655}/letta/agent.py

@@ -1,5 +1,6 @@
 import datetime
 import inspect
+import time
 import traceback
 import warnings
 from abc import ABC, abstractmethod
@@ -566,60 +567,60 @@ class Agent(BaseAgent):
         self,
         message_sequence: List[Message],
         function_call: str = "auto",
-        first_message: bool = False,  # hint
+        first_message: bool = False,
         stream: bool = False,  # TODO move to config?
-        fail_on_empty_response: bool = False,
         empty_response_retry_limit: int = 3,
+        backoff_factor: float = 0.5,  # delay multiplier for exponential backoff
+        max_delay: float = 10.0,  # max delay between retries
     ) -> ChatCompletionResponse:
-        """Get response from LLM API"""
-        # Get the allowed tools based on the ToolRulesSolver state
+        """Get response from LLM API with robust retry mechanism."""
+
         allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names()
+        allowed_functions = (
+            self.functions if not allowed_tool_names else [func for func in self.functions if func["name"] in allowed_tool_names]
+        )
 
-        if not allowed_tool_names:
-            # if it's empty, any available tools are fair game
-            allowed_functions = self.functions
-        else:
-            allowed_functions = [func for func in self.functions if func["name"] in allowed_tool_names]
+        for attempt in range(1, empty_response_retry_limit + 1):
+            try:
+                response = create(
+                    llm_config=self.agent_state.llm_config,
+                    messages=message_sequence,
+                    user_id=self.agent_state.user_id,
+                    functions=allowed_functions,
+                    functions_python=self.functions_python,
+                    function_call=function_call,
+                    first_message=first_message,
+                    stream=stream,
+                    stream_interface=self.interface,
+                )
 
-        try:
-            response = create(
-                # agent_state=self.agent_state,
-                llm_config=self.agent_state.llm_config,
-                messages=message_sequence,
-                user_id=self.agent_state.user_id,
-                functions=allowed_functions,
-                functions_python=self.functions_python,
-                function_call=function_call,
-                # hint
-                first_message=first_message,
-                # streaming
-                stream=stream,
-                stream_interface=self.interface,
-            )
+                # These bottom two are retryable
+                if len(response.choices) == 0 or response.choices[0] is None:
+                    raise ValueError(f"API call returned an empty message: {response}")
 
-            if len(response.choices) == 0 or response.choices[0] is None:
-                empty_api_err_message = f"API call didn't return a message: {response}"
-                if fail_on_empty_response or empty_response_retry_limit == 0:
-                    raise Exception(empty_api_err_message)
-                else:
-                    # Decrement retry limit and try again
-                    warnings.warn(empty_api_err_message)
-                    return self._get_ai_reply(
-                        message_sequence, function_call, first_message, stream, fail_on_empty_response, empty_response_retry_limit - 1
-                    )
+                if response.choices[0].finish_reason not in ["stop", "function_call", "tool_calls"]:
+                    if response.choices[0].finish_reason == "length":
+                        # This is not retryable, hence RuntimeError v.s. ValueError
+                        raise RuntimeError("Finish reason was length (maximum context length)")
+                    else:
+                        raise ValueError(f"Bad finish reason from API: {response.choices[0].finish_reason}")
+
+                return response
 
-            # special case for 'length'
-            if response.choices[0].finish_reason == "length":
-                raise Exception("Finish reason was length (maximum context length)")
+            except ValueError as ve:
+                if attempt >= empty_response_retry_limit:
+                    warnings.warn(f"Retry limit reached. Final error: {ve}")
+                    break
+                else:
+                    delay = min(backoff_factor * (2 ** (attempt - 1)), max_delay)
+                    warnings.warn(f"Attempt {attempt} failed: {ve}. Retrying in {delay} seconds...")
+                    time.sleep(delay)
 
-            # catches for soft errors
-            if response.choices[0].finish_reason not in ["stop", "function_call", "tool_calls"]:
-                raise Exception(f"API call finish with bad finish reason: {response}")
+            except Exception as e:
+                # For non-retryable errors, exit immediately
+                raise e
 
-            # unpack with response.choices[0].message.content
-            return response
-        except Exception as e:
-            raise e
+        raise Exception("Retries exhausted and no valid response received.")
 
     def _handle_ai_response(
         self,

{letta_nightly-0.5.4.dev20241130104041 → letta_nightly-0.5.4.dev20241204014655}/letta/cli/cli.py

@@ -220,7 +220,8 @@ def run(
 
         # create agent
         tools = [server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=client.user) for tool_name in agent_state.tool_names]
-        letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools, user=client.user)
+        agent_state.tools = tools
+        letta_agent = Agent(agent_state=agent_state, interface=interface(), user=client.user)
 
     else:  # create new agent
         # create new agent config: override defaults with args if provided

{letta_nightly-0.5.4.dev20241130104041 → letta_nightly-0.5.4.dev20241204014655}/letta/client/client.py

@@ -434,6 +434,7 @@ class RESTClient(AbstractClient):
         debug: bool = False,
         default_llm_config: Optional[LLMConfig] = None,
         default_embedding_config: Optional[EmbeddingConfig] = None,
+        headers: Optional[Dict] = None,
     ):
         """
         Initializes a new instance of Client class.
@@ -442,12 +443,16 @@ class RESTClient(AbstractClient):
             auto_save (bool): Whether to automatically save changes.
             user_id (str): The user ID.
             debug (bool): Whether to print debug information.
-            default
+            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.
         """
         super().__init__(debug=debug)
         self.base_url = base_url
         self.api_prefix = api_prefix
         self.headers = {"accept": "application/json", "authorization": f"Bearer {token}"}
+        if headers:
+            self.headers.update(headers)
         self._default_llm_config = default_llm_config
         self._default_embedding_config = default_embedding_config
 

letta_nightly-0.5.4.dev20241204014655/letta/functions/functions.py

@@ -0,0 +1,89 @@
+import inspect
+from textwrap import dedent  # remove indentation
+from types import ModuleType
+from typing import Dict, List, Optional
+
+from letta.errors import LettaToolCreateError
+from letta.functions.schema_generator import generate_schema
+
+
+def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
+    """Derives the OpenAI JSON schema for a given function source code.
+
+    First, attempts to execute the source code in a custom environment with only the necessary imports.
+    Then, it generates the schema from the function's docstring and signature.
+    """
+    try:
+        # Define a custom environment with necessary imports
+        env = {
+            "Optional": Optional,
+            "List": List,
+            "Dict": Dict,
+            # To support Pydantic models
+            # "BaseModel": BaseModel,
+            # "Field": Field,
+        }
+        env.update(globals())
+
+        # print("About to execute source code...")
+        exec(source_code, env)
+        # print("Source code executed successfully")
+
+        functions = [f for f in env if callable(env[f]) and not f.startswith("__")]
+        if not functions:
+            raise LettaToolCreateError("No callable functions found in source code")
+
+        # print(f"Found functions: {functions}")
+        func = env[functions[-1]]
+
+        if not hasattr(func, "__doc__") or not func.__doc__:
+            raise LettaToolCreateError(f"Function {func.__name__} missing docstring")
+
+        # print("About to generate schema...")
+        try:
+            schema = generate_schema(func, name=name)
+            # print("Schema generated successfully")
+            return schema
+        except TypeError as e:
+            raise LettaToolCreateError(f"Type error in schema generation: {str(e)}")
+        except ValueError as e:
+            raise LettaToolCreateError(f"Value error in schema generation: {str(e)}")
+        except Exception as e:
+            raise LettaToolCreateError(f"Unexpected error in schema generation: {str(e)}")
+
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        raise LettaToolCreateError(f"Schema generation failed: {str(e)}") from e
+
+
+def parse_source_code(func) -> str:
+    """Parse the source code of a function and remove indendation"""
+    source_code = dedent(inspect.getsource(func))
+    return source_code
+
+
+def load_function_set(module: ModuleType) -> dict:
+    """Load the functions and generate schema for them, given a module object"""
+    function_dict = {}
+
+    for attr_name in dir(module):
+        # Get the attribute
+        attr = getattr(module, attr_name)
+
+        # Check if it's a callable function and not a built-in or special method
+        if inspect.isfunction(attr) and attr.__module__ == module.__name__:
+            if attr_name in function_dict:
+                raise ValueError(f"Found a duplicate of function name '{attr_name}'")
+
+            generated_schema = generate_schema(attr)
+            function_dict[attr_name] = {
+                "module": inspect.getsource(module),
+                "python_function": attr,
+                "json_schema": generated_schema,
+            }
+
+    if len(function_dict) == 0:
+        raise ValueError(f"No functions found in module {module}")
+    return function_dict