letta-nightly 0.6.3.dev20241212015858__tar.gz → 0.6.3.dev20241213104231__tar.gz

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.3.dev20241212015858
+Version: 0.6.3.dev20241213104231
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/agent.py

@@ -1371,10 +1371,9 @@ class Agent(BaseAgent):
         # TODO: recall memory
         raise NotImplementedError()
 
-    def attach_source(self, user: PydanticUser, source_id: str, source_manager: SourceManager, ms: MetadataStore):
+    def attach_source(self, user: PydanticUser, source_id: str, source_manager: SourceManager, ms: MetadataStore, page_size: Optional[int] = None):
         """Attach data with name `source_name` to the agent from source_connector."""
         # TODO: eventually, adding a data source should just give access to the retriever the source table, rather than modifying archival memory
-        page_size = 100
         passages = self.passage_manager.list_passages(actor=user, source_id=source_id, limit=page_size)
 
         for passage in passages:

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/data_sources/connectors.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterator, List, Tuple, Optional
+from typing import Dict, Iterator, List, Tuple
 
 import typer
 
@@ -13,8 +13,6 @@ from letta.schemas.passage import Passage
 from letta.schemas.source import Source
 from letta.services.passage_manager import PassageManager
 from letta.services.source_manager import SourceManager
-from letta.utils import create_uuid_from_string
-
 
 class DataConnector:
     """
@@ -42,7 +40,7 @@ class DataConnector:
         """
 
 
-def load_data(connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User", agent_id: Optional[str] = None):
+def load_data(connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User"):
     """Load data from a connector (generates file and passages) into a specified source_id, associated with a user_id."""
     embedding_config = source.embedding_config
 
@@ -79,10 +77,8 @@ def load_data(connector: DataConnector, source: Source, passage_manager: Passage
                 continue
 
             passage = Passage(
-                id=create_uuid_from_string(f"{str(source.id)}_{passage_text}"),
                 text=passage_text,
                 file_id=file_metadata.id,
-                agent_id=agent_id,
                 source_id=source.id,
                 metadata_=passage_metadata,
                 organization_id=source.organization_id,

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/orm/passage.py

@@ -1,6 +1,6 @@
 from datetime import datetime
-from typing import List, Optional, TYPE_CHECKING
-from sqlalchemy import Column, String, DateTime, Index, JSON, UniqueConstraint, ForeignKey
+from typing import Optional, TYPE_CHECKING
+from sqlalchemy import Column, String, DateTime, JSON, ForeignKey
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.types import TypeDecorator, BINARY
 
@@ -9,7 +9,7 @@ import base64
 
 from letta.orm.source import EmbeddingConfigColumn
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin
+from letta.orm.mixins import FileMixin, OrganizationMixin
 from letta.schemas.passage import Passage as PydanticPassage
 
 from letta.config import LettaConfig
@@ -19,7 +19,6 @@ from letta.settings import settings
 config = LettaConfig()
 
 if TYPE_CHECKING:
-    from letta.orm.file import File
     from letta.orm.organization import Organization
 
 class CommonVector(TypeDecorator):

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/server/server.py

@@ -1345,17 +1345,10 @@ class SyncServer(Server):
         letta_agent = self.load_agent(agent_id=agent_id)
 
         # Insert into archival memory
-        passage_ids = self.passage_manager.insert_passage(
-            agent_state=letta_agent.agent_state, agent_id=agent_id, text=memory_contents, actor=actor, return_ids=True
+        return self.passage_manager.insert_passage(
+            agent_state=letta_agent.agent_state, agent_id=agent_id, text=memory_contents, actor=actor
         )
 
-        # Update the agent
-        # TODO: should this update the system prompt?
-        save_agent(letta_agent, self.ms)
-
-        # TODO: this is gross, fix
-        return [self.passage_manager.get_passage_by_id(passage_id=passage_id, actor=actor) for passage_id in passage_ids]
-
     def delete_archival_memory(self, user_id: str, agent_id: str, memory_id: str):
         actor = self.user_manager.get_user_by_id(user_id=user_id)
         if actor is None:
@@ -1584,6 +1577,8 @@ class SyncServer(Server):
         from letta.data_sources.connectors import DirectoryConnector
 
         source = self.source_manager.get_source_by_id(source_id=source_id)
+        if source is None:
+            raise ValueError(f"Source {source_id} does not exist")
         connector = DirectoryConnector(input_files=[file_path])
         num_passages, num_documents = self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
 
@@ -1593,6 +1588,15 @@ class SyncServer(Server):
         job.metadata_["num_documents"] = num_documents
         self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
 
+        # update all agents who have this source attached
+        agent_ids = self.ms.list_attached_agents(source_id=source_id)
+        for agent_id in agent_ids:
+            agent = self.load_agent(agent_id=agent_id)
+            curr_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+            agent.attach_source(user=actor, source_id=source_id, source_manager=self.source_manager, ms=self.ms)
+            new_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+            assert new_passage_size >= curr_passage_size # in case empty files are added
+
         return job
 
     def load_data(
@@ -1600,7 +1604,6 @@ class SyncServer(Server):
         user_id: str,
         connector: DataConnector,
         source_name: str,
-        agent_id: Optional[str] = None,
     ) -> Tuple[int, int]:
         """Load data from a DataConnector into a source for a specified user_id"""
         # TODO: this should be implemented as a batch job or at least async, since it may take a long time
@@ -1612,9 +1615,7 @@ class SyncServer(Server):
             raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
 
         # load data into the document store
-        passage_count, document_count = load_data(
-            connector, source, self.passage_manager, self.source_manager, actor=user, agent_id=agent_id
-        )
+        passage_count, document_count = load_data(connector, source, self.passage_manager, self.source_manager, actor=user)
         return passage_count, document_count
 
     def attach_source_to_agent(
@@ -1956,6 +1957,21 @@ class SyncServer(Server):
             if sandbox_run_result is None:
                 raise ValueError(f"Tool with id {tool.id} returned execution with None")
             function_response = str(sandbox_run_result.func_return)
+            stdout = [s for s in sandbox_run_result.stdout if s.strip()]
+            stderr = [s for s in sandbox_run_result.stderr if s.strip()]
+
+            # expected error
+            if stderr:
+                error_msg = self.get_error_msg_for_func_return(tool.name, stderr[-1])
+                return FunctionReturn(
+                    id="null",
+                    function_call_id="null",
+                    date=get_utc_time(),
+                    status="error",
+                    function_return=error_msg,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
 
             return FunctionReturn(
                 id="null",
@@ -1963,17 +1979,13 @@ class SyncServer(Server):
                 date=get_utc_time(),
                 status="success",
                 function_return=function_response,
-                stdout=sandbox_run_result.stdout,
-                stderr=sandbox_run_result.stderr,
+                stdout=stdout,
+                stderr=stderr,
             )
-        except Exception as e:
-            # same as agent.py
-            from letta.constants import MAX_ERROR_MESSAGE_CHAR_LIMIT
-
-            error_msg = f"Error executing tool {tool.name}: {e}"
-            if len(error_msg) > MAX_ERROR_MESSAGE_CHAR_LIMIT:
-                error_msg = error_msg[:MAX_ERROR_MESSAGE_CHAR_LIMIT]
 
+        # unexpected error TODO(@cthomas): consolidate error handling
+        except Exception as e:
+            error_msg = self.get_error_msg_for_func_return(tool.name, e)
             return FunctionReturn(
                 id="null",
                 function_call_id="null",
@@ -1984,6 +1996,17 @@ class SyncServer(Server):
                 stderr=[traceback.format_exc()],
             )
 
+
+    def get_error_msg_for_func_return(self, tool_name, exception_message):
+        # same as agent.py
+        from letta.constants import MAX_ERROR_MESSAGE_CHAR_LIMIT
+
+        error_msg = f"Error executing tool {tool_name}: {exception_message}"
+        if len(error_msg) > MAX_ERROR_MESSAGE_CHAR_LIMIT:
+            error_msg = error_msg[:MAX_ERROR_MESSAGE_CHAR_LIMIT]
+        return error_msg
+
+
     # Composio wrappers
     def get_composio_client(self, api_key: Optional[str] = None):
         if api_key:

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/services/passage_manager.py

@@ -26,11 +26,8 @@ class PassageManager:
     def get_passage_by_id(self, passage_id: str, actor: PydanticUser) -> Optional[PydanticPassage]:
         """Fetch a passage by ID."""
         with self.session_maker() as session:
-            try:
-                passage = PassageModel.read(db_session=session, identifier=passage_id, actor=actor)
-                return passage.to_pydantic()
-            except NoResultFound:
-                return None
+            passage = PassageModel.read(db_session=session, identifier=passage_id, actor=actor)
+            return passage.to_pydantic()
 
     @enforce_types
     def create_passage(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
@@ -83,11 +80,6 @@ class PassageManager:
                     actor=actor
                 )
                 passages.append(passage)
-
-            ids = [str(p.id) for p in passages]
-
-            if return_ids:
-                return ids
             
             return passages
 
@@ -101,26 +93,23 @@ class PassageManager:
             raise ValueError("Passage ID must be provided.")
 
         with self.session_maker() as session:
-            try:
-                # Fetch existing message from database
-                curr_passage = PassageModel.read(
-                    db_session=session,
-                    identifier=passage_id,
-                    actor=actor,
-                )
-                if not curr_passage:
-                    raise ValueError(f"Passage with id {passage_id} does not exist.")
+            # Fetch existing message from database
+            curr_passage = PassageModel.read(
+                db_session=session,
+                identifier=passage_id,
+                actor=actor,
+            )
+            if not curr_passage:
+                raise ValueError(f"Passage with id {passage_id} does not exist.")
 
-                # Update the database record with values from the provided record
-                update_data = passage.model_dump(exclude_unset=True, exclude_none=True)
-                for key, value in update_data.items():
-                    setattr(curr_passage, key, value)
+            # Update the database record with values from the provided record
+            update_data = passage.model_dump(exclude_unset=True, exclude_none=True)
+            for key, value in update_data.items():
+                setattr(curr_passage, key, value)
 
-                # Commit changes
-                curr_passage.update(session, actor=actor)
-                return curr_passage.to_pydantic()
-            except NoResultFound:
-                return None
+            # Commit changes
+            curr_passage.update(session, actor=actor)
+            return curr_passage.to_pydantic()
 
     @enforce_types
     def delete_passage_by_id(self, passage_id: str, actor: PydanticUser) -> bool:
@@ -145,6 +134,7 @@ class PassageManager:
                       query_text      : Optional[str] = None,
                       start_date      : Optional[datetime] = None,
                       end_date        : Optional[datetime] = None,
+                      ascending       : bool = True,
                       source_id       : Optional[str] = None,
                       embed_query    : bool = False,
                       embedding_config: Optional[EmbeddingConfig] = None
@@ -176,6 +166,7 @@ class PassageManager:
                 start_date=start_date,
                 end_date=end_date,
                 limit=limit,
+                ascending=ascending,
                 query_text=query_text if not embedded_text else None,
                 query_embedding=embedded_text,
                 **filters

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/letta/services/tool_execution_sandbox.py

@@ -7,6 +7,7 @@ import runpy
 import subprocess
 import sys
 import tempfile
+import traceback
 import uuid
 import venv
 from typing import Any, Dict, Optional, TextIO
@@ -174,41 +175,16 @@ class ToolExecutionSandbox:
                 capture_output=True,
                 text=True,
             )
-
-            # Handle error with optimistic error parsing from the string
-            # This is very brittle, so we fall back to a RuntimeError if parsing fails
-            if result.returncode != 0:
-                # Log the error
-                logger.error(f"Sandbox execution error:\n{result.stderr}")
-
-                # Parse and raise the actual error from stderr
-                tb_lines = result.stderr.strip().splitlines()
-                exception_line = tb_lines[-1]  # The last line contains the exception
-
-                try:
-                    # Split exception type and message
-                    exception_type, exception_message = exception_line.split(": ", 1)
-                    exception_type = exception_type.strip()
-                    exception_message = exception_message.strip()
-
-                    # Dynamically raise the exception
-                    exception_class = eval(exception_type)  # Look up the exception type
-
-                except Exception:
-                    # Fallback to RuntimeError if parsing fails
-                    raise RuntimeError(result.stderr)
-
-                raise exception_class(exception_message)
-
             func_result, stdout = self.parse_out_function_results_markers(result.stdout)
             func_return, agent_state = self.parse_best_effort(func_result)
             return SandboxRunResult(
-                func_return=func_return, 
+                func_return=func_return,
                 agent_state=agent_state,
                 stdout=[stdout],
                 stderr=[result.stderr],
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
+
         except subprocess.TimeoutExpired:
             raise TimeoutError(f"Executing tool {self.tool_name} has timed out.")
         except subprocess.CalledProcessError as e:
@@ -217,39 +193,49 @@ class ToolExecutionSandbox:
         except Exception as e:
             logger.error(f"Executing tool {self.tool_name} has an unexpected error: {e}")
             raise e
+        
 
     def run_local_dir_sandbox_runpy(
         self, sbx_config: SandboxConfig, env_vars: Dict[str, str], temp_file_path: str, old_stdout: TextIO, old_stderr: TextIO
     ) -> SandboxRunResult:
+        func_return, agent_state, error_msg = None, None, None
+
         # Redirect stdout and stderr to capture script output
-        captured_stdout = io.StringIO()
-        captured_stderr = io.StringIO()
+        captured_stdout, captured_stderr = io.StringIO(), io.StringIO()
         sys.stdout = captured_stdout
         sys.stderr = captured_stderr
 
-        # Execute the temp file
-        with self.temporary_env_vars(env_vars):
-            result = runpy.run_path(temp_file_path, init_globals=env_vars)
+        try:
+            # Execute the temp file
+            with self.temporary_env_vars(env_vars):
+                result = runpy.run_path(temp_file_path, init_globals=env_vars)
+
+            # Fetch the result
+            func_result = result.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
+            func_return, agent_state = self.parse_best_effort(func_result)
 
-        # Fetch the result
-        func_result = result.get(self.LOCAL_SANDBOX_RESULT_VAR_NAME)
-        func_return, agent_state = self.parse_best_effort(func_result)
+        except Exception as e:
+            traceback.print_exc(file=sys.stderr)
+            error_msg = f"{type(e).__name__}: {str(e)}"
 
         # Restore stdout and stderr and collect captured output
         sys.stdout = old_stdout
         sys.stderr = old_stderr
-        stdout_output = captured_stdout.getvalue()
-        stderr_output = captured_stderr.getvalue()
+        stdout_output = [captured_stdout.getvalue()]
+        stderr_output = [captured_stderr.getvalue()]
+        stderr_output.append(error_msg if error_msg else '')
 
         return SandboxRunResult(
             func_return=func_return,
             agent_state=agent_state,
-            stdout=[stdout_output],
-            stderr=[stderr_output],
+            stdout=stdout_output,
+            stderr=stderr_output,
             sandbox_config_fingerprint=sbx_config.fingerprint(),
         )
 
     def parse_out_function_results_markers(self, text: str):
+        if self.LOCAL_SANDBOX_RESULT_START_MARKER not in text:
+            return '', text
         marker_len = len(self.LOCAL_SANDBOX_RESULT_START_MARKER)
         start_index = text.index(self.LOCAL_SANDBOX_RESULT_START_MARKER) + marker_len
         end_index = text.index(self.LOCAL_SANDBOX_RESULT_END_MARKER)
@@ -294,21 +280,22 @@ class ToolExecutionSandbox:
         env_vars = self.sandbox_config_manager.get_sandbox_env_vars_as_dict(sandbox_config_id=sbx_config.id, actor=self.user, limit=100)
         code = self.generate_execution_script(agent_state=agent_state)
         execution = sbx.run_code(code, envs=env_vars)
+        func_return, agent_state = None, None
         if execution.error is not None:
             logger.error(f"Executing tool {self.tool_name} failed with {execution.error}")
-            # Raise a concise exception as this gets returned to the LLM
-            raise self.parse_exception_from_e2b_execution(execution)
+            execution.logs.stderr.append(execution.error.traceback) 
+            execution.logs.stderr.append(f"{execution.error.name}: {execution.error.value}") 
         elif len(execution.results) == 0:
             return None
         else:
             func_return, agent_state = self.parse_best_effort(execution.results[0].text)
-            return SandboxRunResult(
-                func_return=func_return,
-                agent_state=agent_state,
-                stdout=execution.logs.stdout,
-                stderr=execution.logs.stderr,
-                sandbox_config_fingerprint=sbx_config.fingerprint(),
-            )
+        return SandboxRunResult(
+            func_return=func_return,
+            agent_state=agent_state,
+            stdout=execution.logs.stdout,
+            stderr=execution.logs.stderr,
+            sandbox_config_fingerprint=sbx_config.fingerprint(),
+        )
 
     def parse_exception_from_e2b_execution(self, e2b_execution: "Execution") -> Exception:
         builtins_dict = __builtins__ if isinstance(__builtins__, dict) else vars(__builtins__)
@@ -356,6 +343,8 @@ class ToolExecutionSandbox:
     # general utility functions
 
     def parse_best_effort(self, text: str) -> Any:
+        if not text:
+            return None, None
         result = pickle.loads(base64.b64decode(text))
         agent_state = None
         if not result["agent_state"] is None:

{letta_nightly-0.6.3.dev20241212015858 → letta_nightly-0.6.3.dev20241213104231}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.3.dev20241212015858"
+version = "0.6.3.dev20241213104231"
 packages = [
     {include = "letta"}
 ]