letta-nightly 0.6.0.dev20241204213946__py3-none-any.whl → 0.6.0.dev20241205104308__py3-none-any.whl

letta/client/client.py

@@ -2859,8 +2859,12 @@ class LocalClient(AbstractClient):
         Returns:
             job (Job): Data loading job including job status and metadata
         """
-        metadata_ = {"type": "embedding", "filename": filename, "source_id": source_id}
-        job = self.server.create_job(user_id=self.user_id, metadata=metadata_)
+        job = Job(
+            user_id=self.user_id,
+            status=JobStatus.created,
+            metadata_={"type": "embedding", "filename": filename, "source_id": source_id},
+        )
+        job = self.server.job_manager.create_job(pydantic_job=job, actor=self.user)
 
         # TODO: implement blocking vs. non-blocking
         self.server.load_file_to_source(source_id=source_id, file_path=filename, job_id=job.id)
@@ -2870,16 +2874,16 @@ class LocalClient(AbstractClient):
         self.server.source_manager.delete_file(file_id, actor=self.user)
 
     def get_job(self, job_id: str):
-        return self.server.get_job(job_id=job_id)
+        return self.server.job_manager.get_job_by_id(job_id=job_id, actor=self.user)
 
     def delete_job(self, job_id: str):
-        return self.server.delete_job(job_id)
+        return self.server.job_manager.delete_job(job_id=job_id, actor=self.user)
 
     def list_jobs(self):
-        return self.server.list_jobs(user_id=self.user_id)
+        return self.server.job_manager.list_jobs(actor=self.user)
 
     def list_active_jobs(self):
-        return self.server.list_active_jobs(user_id=self.user_id)
+        return self.server.job_manager.list_jobs(actor=self.user, statuses=[JobStatus.created, JobStatus.running])
 
     def create_source(self, name: str, embedding_config: Optional[EmbeddingConfig] = None) -> Source:
         """

letta/metadata.py

@@ -12,15 +12,14 @@ from letta.orm.base import Base
 from letta.schemas.agent import PersistedAgentState
 from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import JobStatus, ToolRuleType
-from letta.schemas.job import Job
+from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
 from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.settings import settings
-from letta.utils import enforce_types, get_utc_time, printd
+from letta.utils import enforce_types, printd
 
 
 class LLMConfigColumn(TypeDecorator):
@@ -258,31 +257,6 @@ class AgentSourceMappingModel(Base):
         return f"<AgentSourceMapping(user_id='{self.user_id}', agent_id='{self.agent_id}', source_id='{self.source_id}')>"
 
 
-class JobModel(Base):
-    __tablename__ = "jobs"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True)
-    user_id = Column(String)
-    status = Column(String, default=JobStatus.pending)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-    completed_at = Column(DateTime(timezone=True), onupdate=func.now())
-    metadata_ = Column(JSON)
-
-    def __repr__(self) -> str:
-        return f"<Job(id='{self.id}', status='{self.status}')>"
-
-    def to_record(self):
-        return Job(
-            id=self.id,
-            user_id=self.user_id,
-            status=self.status,
-            created_at=self.created_at,
-            completed_at=self.completed_at,
-            metadata_=self.metadata_,
-        )
-
-
 class MetadataStore:
     uri: Optional[str] = None
 
@@ -455,40 +429,3 @@ class MetadataStore:
                 AgentSourceMappingModel.agent_id == agent_id, AgentSourceMappingModel.source_id == source_id
             ).delete()
             session.commit()
-
-    @enforce_types
-    def create_job(self, job: Job):
-        with self.session_maker() as session:
-            session.add(JobModel(**vars(job)))
-            session.commit()
-
-    def delete_job(self, job_id: str):
-        with self.session_maker() as session:
-            session.query(JobModel).filter(JobModel.id == job_id).delete()
-            session.commit()
-
-    def get_job(self, job_id: str) -> Optional[Job]:
-        with self.session_maker() as session:
-            results = session.query(JobModel).filter(JobModel.id == job_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    def list_jobs(self, user_id: str) -> List[Job]:
-        with self.session_maker() as session:
-            results = session.query(JobModel).filter(JobModel.user_id == user_id).all()
-            return [r.to_record() for r in results]
-
-    def update_job(self, job: Job) -> Job:
-        with self.session_maker() as session:
-            session.query(JobModel).filter(JobModel.id == job.id).update(vars(job))
-            session.commit()
-        return Job
-
-    def update_job_status(self, job_id: str, status: JobStatus):
-        with self.session_maker() as session:
-            session.query(JobModel).filter(JobModel.id == job_id).update({"status": status})
-            if status == JobStatus.COMPLETED:
-                session.query(JobModel).filter(JobModel.id == job_id).update({"completed_at": get_utc_time()})
-            session.commit()

letta/orm/__init__.py

@@ -2,6 +2,7 @@ from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
+from letta.orm.job import Job
 from letta.orm.organization import Organization
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source

letta/orm/job.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import JSON, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import UserMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import JobStatus
+from letta.schemas.job import Job as PydanticJob
+
+if TYPE_CHECKING:
+    from letta.orm.user import User
+
+
+class Job(SqlalchemyBase, UserMixin):
+    """Jobs run in the background and are owned by a user.
+    Typical jobs involve loading and processing sources etc.
+    """
+
+    __tablename__ = "jobs"
+    __pydantic_model__ = PydanticJob
+
+    status: Mapped[JobStatus] = mapped_column(String, default=JobStatus.created, doc="The current status of the job.")
+    completed_at: Mapped[Optional[datetime]] = mapped_column(nullable=True, doc="The unix timestamp of when the job was completed.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The metadata of the job.")
+
+    # relationships
+    user: Mapped["User"] = relationship("User", back_populates="jobs")

letta/orm/sqlalchemy_base.py

@@ -31,24 +31,43 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     def list(
         cls, *, db_session: "Session", cursor: Optional[str] = None, limit: Optional[int] = 50, **kwargs
     ) -> List[Type["SqlalchemyBase"]]:
-        """List records with optional cursor (for pagination) and limit."""
-        logger.debug(f"Listing {cls.__name__} with kwarg filters {kwargs}")
-        with db_session as session:
-            # Start with the base query filtered by kwargs
-            query = select(cls).filter_by(**kwargs)
+        """
+        List records with optional cursor (for pagination), limit, and automatic filtering.
+
+        Args:
+            db_session: The database session to use.
+            cursor: Optional ID to start pagination from.
+            limit: Maximum number of records to return.
+            **kwargs: Filters passed as equality conditions or iterable for IN filtering.
 
-            # Add a cursor condition if provided
+        Returns:
+            A list of model instances matching the filters.
+        """
+        logger.debug(f"Listing {cls.__name__} with filters {kwargs}")
+        with db_session as session:
+            # Start with a base query
+            query = select(cls)
+
+            # Apply filtering logic
+            for key, value in kwargs.items():
+                column = getattr(cls, key)
+                if isinstance(value, (list, tuple, set)):  # Check for iterables
+                    query = query.where(column.in_(value))
+                else:  # Single value for equality filtering
+                    query = query.where(column == value)
+
+            # Apply cursor for pagination
             if cursor:
                 query = query.where(cls.id > cursor)
 
-            # Add a limit to the query if provided
-            query = query.order_by(cls.id).limit(limit)
-
             # Handle soft deletes if the class has the 'is_deleted' attribute
             if hasattr(cls, "is_deleted"):
                 query = query.where(cls.is_deleted == False)
 
-            # Execute the query and return the results as a list of model instances
+            # Add ordering and limit
+            query = query.order_by(cls.id).limit(limit)
+
+            # Execute the query and return results as model instances
             return list(session.execute(query).scalars())
 
     @classmethod

letta/orm/user.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -7,7 +7,7 @@ from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.user import User as PydanticUser
 
 if TYPE_CHECKING:
-    from letta.orm.organization import Organization
+    from letta.orm import Job, Organization
 
 
 class User(SqlalchemyBase, OrganizationMixin):
@@ -20,10 +20,10 @@ class User(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="users")
+    jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.")
 
     # TODO: Add this back later potentially
     # agents: Mapped[List["Agent"]] = relationship(
     #     "Agent", secondary="users_agents", back_populates="users", doc="the agents associated with this user."
     # )
     # tokens: Mapped[List["Token"]] = relationship("Token", back_populates="user", doc="the tokens associated with this user.")
-    # jobs: Mapped[List["Job"]] = relationship("Job", back_populates="user", doc="the jobs associated with this user.")

letta/schemas/job.py

@@ -4,12 +4,13 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.enums import JobStatus
-from letta.schemas.letta_base import LettaBase
-from letta.utils import get_utc_time
+from letta.schemas.letta_base import OrmMetadataBase
 
 
-class JobBase(LettaBase):
+class JobBase(OrmMetadataBase):
     __id_prefix__ = "job"
+    status: JobStatus = Field(default=JobStatus.created, description="The status of the job.")
+    completed_at: Optional[datetime] = Field(None, description="The unix timestamp of when the job was completed.")
     metadata_: Optional[dict] = Field(None, description="The metadata of the job.")
 
 
@@ -27,12 +28,11 @@ class Job(JobBase):
     """
 
     id: str = JobBase.generate_id_field()
-    status: JobStatus = Field(default=JobStatus.created, description="The status of the job.")
-    created_at: datetime = Field(default_factory=get_utc_time, description="The unix timestamp of when the job was created.")
-    completed_at: Optional[datetime] = Field(None, description="The unix timestamp of when the job was completed.")
-    user_id: str = Field(..., description="The unique identifier of the user associated with the job.")
+    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the job.")
 
 
 class JobUpdate(JobBase):
-    id: str = Field(..., description="The unique identifier of the job.")
-    status: Optional[JobStatus] = Field(..., description="The status of the job.")
+    status: Optional[JobStatus] = Field(None, description="The status of the job.")
+
+    class Config:
+        extra = "ignore"  # Ignores extra fields

letta/server/rest_api/routers/v1/jobs.py

@@ -2,6 +2,8 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Depends, Header, HTTPException, Query
 
+from letta.orm.errors import NoResultFound
+from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
@@ -21,12 +23,11 @@ def list_jobs(
     actor = server.get_user_or_default(user_id=user_id)
 
     # TODO: add filtering by status
-    jobs = server.list_jobs(user_id=actor.id)
+    jobs = server.job_manager.list_jobs(actor=actor)
 
-    # TODO: eventually use ORM
-    # results = session.query(JobModel).filter(JobModel.user_id == user_id, JobModel.metadata_["source_id"].astext == sourced_id).all()
     if source_id:
         # can't be in the ORM since we have source_id stored in the metadata_
+        # TODO: Probably change this
         jobs = [job for job in jobs if job.metadata_.get("source_id") == source_id]
     return jobs
 
@@ -41,32 +42,39 @@ def list_active_jobs(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.list_active_jobs(user_id=actor.id)
+    return server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
 
 @router.get("/{job_id}", response_model=Job, operation_id="get_job")
 def get_job(
     job_id: str,
+    user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Get the status of a job.
     """
+    actor = server.get_user_or_default(user_id=user_id)
 
-    return server.get_job(job_id=job_id)
+    try:
+        return server.job_manager.get_job_by_id(job_id=job_id, actor=actor)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Job not found")
 
 
 @router.delete("/{job_id}", response_model=Job, operation_id="delete_job")
 def delete_job(
     job_id: str,
+    user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Delete a job by its job_id.
     """
-    job = server.get_job(job_id=job_id)
-    if not job:
-        raise HTTPException(status_code=404, detail="Job not found")
+    actor = server.get_user_or_default(user_id=user_id)
 
-    server.delete_job(job_id=job_id)
-    return job
+    try:
+        job = server.job_manager.delete_job_by_id(job_id=job_id, actor=actor)
+        return job
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Job not found")

letta/server/rest_api/routers/v1/sources.py

@@ -16,6 +16,7 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
+from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.utils import sanitize_filename
@@ -175,13 +176,14 @@ def upload_file_to_source(
         completed_at=None,
     )
     job_id = job.id
-    server.ms.create_job(job)
+    server.job_manager.create_job(job, actor=actor)
 
     # create background task
-    background_tasks.add_task(load_file_to_source_async, server, source_id=source.id, file=file, job_id=job.id, bytes=bytes)
+    background_tasks.add_task(load_file_to_source_async, server, source_id=source.id, file=file, job_id=job.id, bytes=bytes, actor=actor)
 
     # return job information
-    job = server.ms.get_job(job_id=job_id)
+    # Is this necessary? Can we just return the job from create_job?
+    job = server.job_manager.get_job_by_id(job_id=job_id, actor=actor)
     assert job is not None, "Job not found"
     return job
 
@@ -234,7 +236,7 @@ def delete_file_from_source(
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 
 
-def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes):
+def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, file: UploadFile, bytes: bytes, actor: User):
     # Create a temporary directory (deleted after the context manager exits)
     with tempfile.TemporaryDirectory() as tmpdirname:
         # Sanitize the filename
@@ -246,4 +248,4 @@ def load_file_to_source_async(server: SyncServer, source_id: str, job_id: str, f
             buffer.write(bytes)
 
         # Pass the file to load_file_to_source
-        server.load_file_to_source(source_id, file_path, job_id)
+        server.load_file_to_source(source_id, file_path, job_id, actor)

letta/server/server.py

@@ -6,7 +6,7 @@ import warnings
 from abc import abstractmethod
 from asyncio import Lock
 from datetime import datetime
-from typing import Callable, Dict, List, Optional, Tuple, Union
+from typing import Callable, List, Optional, Tuple, Union
 
 from composio.client import Composio
 from composio.client.collections import ActionModel, AppModel
@@ -56,7 +56,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus
-from letta.schemas.job import Job
+from letta.schemas.job import Job, JobUpdate
 from letta.schemas.letta_message import FunctionReturn, LettaMessage
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import (
@@ -75,6 +75,7 @@ from letta.schemas.user import User
 from letta.services.agents_tags_manager import AgentsTagsManager
 from letta.services.block_manager import BlockManager
 from letta.services.blocks_agents_manager import BlocksAgentsManager
+from letta.services.job_manager import JobManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
@@ -256,6 +257,7 @@ class SyncServer(Server):
         self.agents_tags_manager = AgentsTagsManager()
         self.sandbox_config_manager = SandboxConfigManager(tool_settings)
         self.blocks_agents_manager = BlocksAgentsManager()
+        self.job_manager = JobManager()
 
         # Managers that interface with parallelism
         self.per_agent_lock_manager = PerAgentLockManager()
@@ -1469,39 +1471,12 @@ class SyncServer(Server):
 
         # TODO: delete data from agent passage stores (?)
 
-    def create_job(self, user_id: str, metadata: Optional[Dict] = None) -> Job:
-        """Create a new job"""
-        job = Job(
-            user_id=user_id,
-            status=JobStatus.created,
-            metadata_=metadata,
-        )
-        self.ms.create_job(job)
-        return job
-
-    def delete_job(self, job_id: str):
-        """Delete a job"""
-        self.ms.delete_job(job_id)
-
-    def get_job(self, job_id: str) -> Job:
-        """Get a job"""
-        return self.ms.get_job(job_id)
-
-    def list_jobs(self, user_id: str) -> List[Job]:
-        """List all jobs for a user"""
-        return self.ms.list_jobs(user_id=user_id)
-
-    def list_active_jobs(self, user_id: str) -> List[Job]:
-        """List all active jobs for a user"""
-        jobs = self.ms.list_jobs(user_id=user_id)
-        return [job for job in jobs if job.status in [JobStatus.created, JobStatus.running]]
-
-    def load_file_to_source(self, source_id: str, file_path: str, job_id: str) -> Job:
+    def load_file_to_source(self, source_id: str, file_path: str, job_id: str, actor: User) -> Job:
 
         # update job
-        job = self.ms.get_job(job_id)
+        job = self.job_manager.get_job_by_id(job_id, actor=actor)
         job.status = JobStatus.running
-        self.ms.update_job(job)
+        self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
 
         # try:
         from letta.data_sources.connectors import DirectoryConnector
@@ -1509,23 +1484,12 @@ class SyncServer(Server):
         source = self.source_manager.get_source_by_id(source_id=source_id)
         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)
-        # except Exception as e:
-        #    # job failed with error
-        #    error = str(e)
-        #    print(error)
-        #    job.status = JobStatus.failed
-        #    job.metadata_["error"] = error
-        #    self.ms.update_job(job)
-        #    # TODO: delete any associated passages/files?
-
-        #    # return failed job
-        #    return job
 
         # update job status
         job.status = JobStatus.completed
         job.metadata_["num_passages"] = num_passages
         job.metadata_["num_documents"] = num_documents
-        self.ms.update_job(job)
+        self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
 
         return job
 

letta/services/job_manager.py

@@ -0,0 +1,85 @@
+from typing import List, Optional
+
+from letta.orm.job import Job as JobModel
+from letta.schemas.enums import JobStatus
+from letta.schemas.job import Job as PydanticJob
+from letta.schemas.job import JobUpdate
+from letta.schemas.user import User as PydanticUser
+from letta.utils import enforce_types, get_utc_time
+
+
+class JobManager:
+    """Manager class to handle business logic related to Jobs."""
+
+    def __init__(self):
+        # Fetching the db_context similarly as in OrganizationManager
+        from letta.server.server import db_context
+
+        self.session_maker = db_context
+
+    @enforce_types
+    def create_job(self, pydantic_job: PydanticJob, actor: PydanticUser) -> PydanticJob:
+        """Create a new job based on the JobCreate schema."""
+        with self.session_maker() as session:
+            # Associate the job with the user
+            pydantic_job.user_id = actor.id
+            job_data = pydantic_job.model_dump()
+            job = JobModel(**job_data)
+            job.create(session, actor=actor)  # Save job in the database
+        return job.to_pydantic()
+
+    @enforce_types
+    def update_job_by_id(self, job_id: str, job_update: JobUpdate, actor: PydanticUser) -> PydanticJob:
+        """Update a job by its ID with the given JobUpdate object."""
+        with self.session_maker() as session:
+            # Fetch the job by ID
+            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
+
+            # Update job attributes with only the fields that were explicitly set
+            update_data = job_update.model_dump(exclude_unset=True, exclude_none=True)
+
+            # Automatically update the completion timestamp if status is set to 'completed'
+            if update_data.get("status") == JobStatus.completed and not job.completed_at:
+                job.completed_at = get_utc_time()
+
+            for key, value in update_data.items():
+                setattr(job, key, value)
+
+            # Save the updated job to the database
+            return job.update(db_session=session)  # TODO: Add this later , actor=actor)
+
+    @enforce_types
+    def get_job_by_id(self, job_id: str, actor: PydanticUser) -> PydanticJob:
+        """Fetch a job by its ID."""
+        with self.session_maker() as session:
+            # Retrieve job by ID using the Job model's read method
+            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
+            return job.to_pydantic()
+
+    @enforce_types
+    def list_jobs(
+        self, actor: PydanticUser, cursor: Optional[str] = None, limit: Optional[int] = 50, statuses: Optional[List[JobStatus]] = None
+    ) -> List[PydanticJob]:
+        """List all jobs with optional pagination and status filter."""
+        with self.session_maker() as session:
+            filter_kwargs = {"user_id": actor.id}
+
+            # Add status filter if provided
+            if statuses:
+                filter_kwargs["status"] = statuses
+
+            jobs = JobModel.list(
+                db_session=session,
+                cursor=cursor,
+                limit=limit,
+                **filter_kwargs,
+            )
+            return [job.to_pydantic() for job in jobs]
+
+    @enforce_types
+    def delete_job_by_id(self, job_id: str, actor: PydanticUser) -> PydanticJob:
+        """Delete a job by its ID."""
+        with self.session_maker() as session:
+            job = JobModel.read(db_session=session, identifier=job_id)  # TODO: Add this later , actor=actor)
+            job.hard_delete(db_session=session)  # TODO: Add this later , actor=actor)
+            return job.to_pydantic()

letta/services/tool_execution_sandbox.py

@@ -159,6 +159,8 @@ class ToolExecutionSandbox:
         # Set up env for venv
         env["VIRTUAL_ENV"] = venv_path
         env["PATH"] = os.path.join(venv_path, "bin") + ":" + env["PATH"]
+        # Suppress all warnings
+        env["PYTHONWARNINGS"] = "ignore"
 
         # Execute the code in a restricted subprocess
         try:
@@ -170,9 +172,31 @@ class ToolExecutionSandbox:
                 capture_output=True,
                 text=True,
             )
-            if result.stderr:
-                logger.error(f"Sandbox execution error: {result.stderr}")
-                raise RuntimeError(f"Sandbox execution error: {result.stderr}")
+
+            # 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)
@@ -182,9 +206,11 @@ class ToolExecutionSandbox:
         except subprocess.TimeoutExpired:
             raise TimeoutError(f"Executing tool {self.tool_name} has timed out.")
         except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Executing tool {self.tool_name} has process error: {e}")
+            logger.error(f"Executing tool {self.tool_name} has process error: {e}")
+            raise e
         except Exception as e:
-            raise RuntimeError(f"Executing tool {self.tool_name} has an unexpected error: {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

letta/utils.py

@@ -15,7 +15,7 @@ import uuid
 from contextlib import contextmanager
 from datetime import datetime, timedelta, timezone
 from functools import wraps
-from typing import List, Union, _GenericAlias, get_type_hints
+from typing import List, Union, _GenericAlias, get_args, get_origin, get_type_hints
 from urllib.parse import urljoin, urlparse
 
 import demjson3 as demjson
@@ -529,16 +529,32 @@ def enforce_types(func):
         # Pair each argument with its corresponding type hint
         args_with_hints = dict(zip(arg_names[1:], args[1:]))  # Skipping 'self'
 
+        # Function to check if a value matches a given type hint
+        def matches_type(value, hint):
+            origin = get_origin(hint)
+            args = get_args(hint)
+
+            if origin is list and isinstance(value, list):  # Handle List[T]
+                element_type = args[0] if args else None
+                return all(isinstance(v, element_type) for v in value) if element_type else True
+            elif origin is Union and type(None) in args:  # Handle Optional[T]
+                non_none_type = next(arg for arg in args if arg is not type(None))
+                return value is None or matches_type(value, non_none_type)
+            elif origin:  # Handle other generics like Dict, Tuple, etc.
+                return isinstance(value, origin)
+            else:  # Handle non-generic types
+                return isinstance(value, hint)
+
         # Check types of arguments
         for arg_name, arg_value in args_with_hints.items():
             hint = hints.get(arg_name)
-            if hint and not isinstance(arg_value, hint) and not (is_optional_type(hint) and arg_value is None):
+            if hint and not matches_type(arg_value, hint):
                 raise ValueError(f"Argument {arg_name} does not match type {hint}")
 
         # Check types of keyword arguments
         for arg_name, arg_value in kwargs.items():
             hint = hints.get(arg_name)
-            if hint and not isinstance(arg_value, hint) and not (is_optional_type(hint) and arg_value is None):
+            if hint and not matches_type(arg_value, hint):
                 raise ValueError(f"Argument {arg_name} does not match type {hint}")
 
         return func(*args, **kwargs)

{letta_nightly-0.6.0.dev20241204213946.dist-info → letta_nightly-0.6.0.dev20241205104308.dist-info}/METADATA

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

{letta_nightly-0.6.0.dev20241204213946.dist-info → letta_nightly-0.6.0.dev20241205104308.dist-info}/RECORD

@@ -13,7 +13,7 @@ letta/cli/cli.py,sha256=fpcpBKEAzKU6o9gSS5pe6YRTkiybIik5CC9mCAVl_bA,16928
 letta/cli/cli_config.py,sha256=tB0Wgz3O9j6KiCsU1HWfsKmhNM9RqLsAxzxEDFQFGnM,8565
 letta/cli/cli_load.py,sha256=x4L8s15GwIW13xrhKYFWHo_y-IVGtoPDHWWKcHDRP10,4587
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=uUEpADbWwm7bhwv2mA4kllyDC6MpnfRKd8CLpP8kEt0,123907
+letta/client/client.py,sha256=hQiTmkmddoGONuSlNG0Yrbo1Y2k9VRTRDFAOtHRbOPI,124143
 letta/client/streaming.py,sha256=Hh5pjlyrdCuO2V75ZCxSSOCPd3BmHdKFGaIUJC6fBp0,4775
 letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=AF4XY6grcu87OLjrWXh1ufnyKWsCL0qER-_9jQCAlU0,18947
@@ -85,12 +85,12 @@ letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ft
 letta/log.py,sha256=FxkAk2f8Bl-u9dfImSj1DYnjAsmV6PL3tjTSnEiNP48,2218
 letta/main.py,sha256=5guUzYyxID3FDlegk3dNUev7vjPMglcIw-xqdyHdhKI,19175
 letta/memory.py,sha256=YupXOvzVJXH59RW4XWBrd7qMNEYaMbtWXCheKeWZwpU,17873
-letta/metadata.py,sha256=IipAhhpLXve8mVRAf4LNQhZxexwt-5lmf7bqCr8hE3E,18643
+letta/metadata.py,sha256=jv_s2Y6M8aE3bpOOTr-xwBBu58zZHx9tYtAekVa_Dz4,16233
 letta/o1_agent.py,sha256=jTMlP7LxR4iUDWaGHMy8SiZtlzn6_RqP0H1HaEWXydQ,3078
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
 letta/orm/__all__.py,sha256=2gh2MZTkA3Hw67VWVKK3JIStJOqTeLdpCvYSVYNeEDA,692
-letta/orm/__init__.py,sha256=3n3rOtlDySptVPM3H1LpT3Ey5mdvQZjK0V0TJwDmaoI,382
+letta/orm/__init__.py,sha256=yXCse66-Va1tuVhoDcHbaLIffBiJKLKF4JR6SAFiIZU,412
 letta/orm/agents_tags.py,sha256=Qa7Yt9imL8xbGP57fflccAMy7Z32CQiU_7eZKSSPngc,1119
 letta/orm/base.py,sha256=K_LpNUURbsj44ycHbzvNXG_n8pBOjf1YvDaikIPDpQA,2716
 letta/orm/block.py,sha256=xymYeCTJJFkzADW6wjfP2LXNZZN9yg4mCSybbvEEMMM,2356
@@ -98,13 +98,14 @@ letta/orm/blocks_agents.py,sha256=o6cfblODja7so4444npW0vusqKcvDPp8YJdsWsOePus,11
 letta/orm/enums.py,sha256=KfHcFt_fR6GUmSlmfsa-TetvmuRxGESNve8MStRYW64,145
 letta/orm/errors.py,sha256=nv1HnF3z4-u9m_g7SO5TO5u2nmJN677_n8F0iIjluUI,460
 letta/orm/file.py,sha256=FtfZlJLXfac4ntaw3kC0N9VRoD255m8EK4p-pC2lcHk,1519
+letta/orm/job.py,sha256=If-qSTJW4t5h-6Jolw3tS3-xMZEaPIbXe3S0GMf_FXI,1102
 letta/orm/mixins.py,sha256=LfwePamGyOwCtAEUm-sZpIBJjODIMe4MnA_JTUcppLs,1155
 letta/orm/organization.py,sha256=mliw4q7-SRfRcGIG8paNfCNn6ITTjR7nFalZzlRszqU,2272
 letta/orm/sandbox_config.py,sha256=PCMHE-eJPzBT-90OYtXjEMRF4f9JB8AJIGETE7bu-f0,2870
 letta/orm/source.py,sha256=Ib0XHCMt345RjBSC30A398rZ21W5mA4PXX00XNXyd24,2021
-letta/orm/sqlalchemy_base.py,sha256=PGkbEb7nz3aNMScQEu55KXxE48Xw7DA01tV9famFmO0,9980
+letta/orm/sqlalchemy_base.py,sha256=CmCwVCHVyhzDAd-xIUFh72bzSX-bA0mwvMUD7FrIlUk,10672
 letta/orm/tool.py,sha256=d0GclU_7qg8Z6ZE6kkH1kmrUAMCiV-ZM8BGaT1mnBU4,2089
-letta/orm/user.py,sha256=bB4qGIT-ZoECZeeVqG-z3Z7WFXGqpC-GPcoYQoJZOuc,1137
+letta/orm/user.py,sha256=bUZzyBQXfR0w7mZAkThPAQE6kKx6W--Rw6uAiPEUW3s,1133
 letta/persistence_manager.py,sha256=sEnNdNisK7StqIzG8eIY0YMag6S9hZFbkDfmY7L2Ikc,5268
 letta/personas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/personas/examples/anna_pa.txt,sha256=zgiNdSNhy1HQy58cF_6RFPzcg2i37F9v38YuL1CW40A,1849
@@ -139,7 +140,7 @@ letta/schemas/embedding_config.py,sha256=1kD6NpiXeH4roVumxqDAKk7xt8SpXGWNhZs_XXU
 letta/schemas/enums.py,sha256=F396hXs57up4Jqj1vwWVknMpoVo7MkccVBALvKGHPpE,1032
 letta/schemas/file.py,sha256=ChN2CWzLI2TT9WLItcfElEH0E8b7kzPylF2OQBr6Beg,1550
 letta/schemas/health.py,sha256=zT6mYovvD17iJRuu2rcaQQzbEEYrkwvAE9TB7iU824c,139
-letta/schemas/job.py,sha256=605TWjUdNy5Rgoc7en_DX3Giz-I7sVTXiSRZqxL__d8,1543
+letta/schemas/job.py,sha256=vRVVpMCHTxot9uaalLS8RARnqzJWvcLB1XP5XRBioPc,1398
 letta/schemas/letta_base.py,sha256=QlCY5BBSjEPNpUvSHDl_P0TXQIPlr7xfhK_2SqKqadQ,3567
 letta/schemas/letta_message.py,sha256=RuVVtwFbi85yP3dXQxowofQ6cI2cO_CdGtgpHGQzgHc,6563
 letta/schemas/letta_request.py,sha256=E6OwKiceNffpdGdQMI1qc0jEfpL_e7O9BTzklOkbt6Y,1019
@@ -181,16 +182,16 @@ letta/server/rest_api/routers/v1/__init__.py,sha256=RZc0fIHNN4BGretjU6_TGK7q49Ry
 letta/server/rest_api/routers/v1/agents.py,sha256=Tj7QyHjem_tOgzDzTyEJREDH2rzDgpE6S5azBDrhY_o,24884
 letta/server/rest_api/routers/v1/blocks.py,sha256=UCVfMbb8hzOXI6a8OYWKuXyOropIxw6PYKZkwwAh1v0,4880
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
-letta/server/rest_api/routers/v1/jobs.py,sha256=a-j0v-5A0un0pVCOHpfeWnzpOWkVDQO6ti42k_qAlZY,2272
+letta/server/rest_api/routers/v1/jobs.py,sha256=gnu__rjcd9SpKdQkSD_sci-xJYH0fw828PuHMcYwsCw,2678
 letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFlJaaO4uL95VY,877
 letta/server/rest_api/routers/v1/organizations.py,sha256=tyqVzXTpMtk3sKxI3Iz4aS6RhbGEbXDzFBB_CpW18v4,2080
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=4tkTH8z9vpuBiGzxrS_wxkFdznnWZx-U-9F08czHMP8,5004
-letta/server/rest_api/routers/v1/sources.py,sha256=HUbcBENk4RZDzxvP9tRANiWLX60nOkMdUCZ48jFGfk8,9630
+letta/server/rest_api/routers/v1/sources.py,sha256=1zIkopcyHDMarOGJISy5yXpi9-yeBRBitJ6_yiIJGdY,9818
 letta/server/rest_api/routers/v1/tools.py,sha256=TP16cpuTF2HYLFZVmabExw9gziB-PtkExtWVkjxrRes,9553
 letta/server/rest_api/routers/v1/users.py,sha256=M1wEr2IyHzuRwINYxLXTkrbAH3osLe_cWjzrWrzR1aw,3729
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=6c5a_-ZFTlwZ1IuzpRQtqxSG1eD56nNhKhWlrdgBYWk,3103
-letta/server/server.py,sha256=tfEnHSTnWKWZslRP-bXYUbM2A2-XiAkbjnGrHQu6NAw,81341
+letta/server/server.py,sha256=ag3y5efyi0zzNC_TTJwJ9-xCbzzIgI2Orz36UDb8zoY,80381
 letta/server/startup.sh,sha256=wTOQOJJZw_Iec57WIu0UW0AVflk0ZMWYZWg8D3T_gSQ,698
 letta/server/static_files/assets/index-3ab03d5b.css,sha256=OrA9W4iKJ5h2Wlr7GwdAT4wow0CM8hVit1yOxEL49Qw,54295
 letta/server/static_files/assets/index-9fa459a2.js,sha256=wtfkyHnEIMACHKL3UgN_jZNOKWEcOFjmWoeRHLngPwk,1815584
@@ -207,11 +208,12 @@ letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/agents_tags_manager.py,sha256=zNqeXDpaf4dQ77jrRHiQfITdk4FawBzcND-9tWrj8gw,3127
 letta/services/block_manager.py,sha256=TrbStwHAREwnybA6jZSkNPe-EYUa5rdiuliPR2PTV-M,5426
 letta/services/blocks_agents_manager.py,sha256=mfO3EMW9os_E1_r4SRlC2wmBFFLpt8p-yhdOH_Iotaw,5627
+letta/services/job_manager.py,sha256=FrkSXloke48CZKuzlYdysxM5gKWoTu7FRigPrs_YW4A,3645
 letta/services/organization_manager.py,sha256=OfE2_NMmhqXURX4sg7hCOiFQVQpV5ZiPu7J3sboCSYc,3555
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
 letta/services/sandbox_config_manager.py,sha256=9BCu59nHR4nIMFXgFyEMOY2UTmZvBMS3GlDBWWCHB4I,12648
 letta/services/source_manager.py,sha256=StX5Wfd7XSCKJet8qExIu3GMoI-eMIbEarAeTv2gq0s,6555
-letta/services/tool_execution_sandbox.py,sha256=HY8W6W0-AlYOc6597WzF-eF_TB-OHhATf2-DT2-4lk4,20215
+letta/services/tool_execution_sandbox.py,sha256=GTWdfAKIMIuODEFbmReyEYkOnE62uzDF-3FHWee1s3A,21295
 letta/services/tool_manager.py,sha256=FVCB9R3NFahh-KE5jROzf6J9WEgqhqGoDk5RpWjlgjg,7835
 letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/user_manager.py,sha256=UJa0hqCjz0yXtvrCR8OVBqlSR5lC_Ejn-uG__58zLds,4398
@@ -219,9 +221,9 @@ letta/settings.py,sha256=ZcUcwvl7hStawZ0JOA0133jNk3j5qBd7qlFAAaIPsU8,3608
 letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,15736
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
-letta/utils.py,sha256=iELiiJhSnijGDmwyk_T4NBJIqFUnEw_Flv9ZpSBUPFA,32136
-letta_nightly-0.6.0.dev20241204213946.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.0.dev20241204213946.dist-info/METADATA,sha256=iNEBlkI4KVar7ahBDGxq6tBLveBGuL7qySYFN2aCcqk,11413
-letta_nightly-0.6.0.dev20241204213946.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.0.dev20241204213946.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.0.dev20241204213946.dist-info/RECORD,,
+letta/utils.py,sha256=7FGZYp8JCEtP0PBSfV03Zj4kW3pwV7qpNki4AOU3a94,32913
+letta_nightly-0.6.0.dev20241205104308.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.0.dev20241205104308.dist-info/METADATA,sha256=gz6eo82cNek6syp2o1gS4FSmOQTzVty0a41NPRc13Hs,11413
+letta_nightly-0.6.0.dev20241205104308.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.0.dev20241205104308.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.0.dev20241205104308.dist-info/RECORD,,