letta-nightly 0.6.9.dev20250115104021__py3-none-any.whl → 0.6.9.dev20250116195713__py3-none-any.whl

letta/functions/helpers.py

@@ -1,10 +1,15 @@
+import json
 from typing import Any, Optional, Union
 
 import humps
 from composio.constants import DEFAULT_ENTITY_ID
 from pydantic import BaseModel
 
-from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY
+from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import AssistantMessage, ReasoningMessage, ToolCallMessage
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.message import MessageCreate
 
 
 def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
@@ -206,3 +211,102 @@ def generate_import_code(module_attr_map: Optional[dict]):
         code_lines.append(f"    # Access the {attr} from the module")
         code_lines.append(f"    {attr} = getattr({module_name}, '{attr}')")
     return "\n".join(code_lines)
+
+
+def parse_letta_response_for_assistant_message(
+    letta_response: LettaResponse,
+    assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
+    assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
+) -> Optional[str]:
+    reasoning_message = ""
+    for m in letta_response.messages:
+        if isinstance(m, AssistantMessage):
+            return m.assistant_message
+        elif isinstance(m, ToolCallMessage) and m.tool_call.name == assistant_message_tool_name:
+            try:
+                return json.loads(m.tool_call.arguments)[assistant_message_tool_kwarg]
+            except Exception:  # TODO: Make this more specific
+                continue
+        elif isinstance(m, ReasoningMessage):
+            # This is not ideal, but we would like to return something rather than nothing
+            reasoning_message += f"{m.reasoning}\n"
+
+    return None
+
+
+import asyncio
+from random import uniform
+from typing import Optional
+
+
+async def async_send_message_with_retries(
+    server,
+    sender_agent: "Agent",
+    target_agent_id: str,
+    message_text: str,
+    max_retries: int,
+    timeout: int,
+    logging_prefix: Optional[str] = None,
+) -> str:
+    """
+    Shared helper coroutine to send a message to an agent with retries and a timeout.
+
+    Args:
+        server: The Letta server instance (from get_letta_server()).
+        sender_agent (Agent): The agent initiating the send action.
+        target_agent_id (str): The ID of the agent to send the message to.
+        message_text (str): The text to send as the user message.
+        max_retries (int): Maximum number of retries for the request.
+        timeout (int): Maximum time to wait for a response (in seconds).
+        logging_prefix (str): A prefix to append to logging
+    Returns:
+        str: The response or an error message.
+    """
+    logging_prefix = logging_prefix or "[async_send_message_with_retries]"
+    for attempt in range(1, max_retries + 1):
+        try:
+            messages = [MessageCreate(role=MessageRole.user, text=message_text, name=sender_agent.agent_state.name)]
+            # Wrap in a timeout
+            response = await asyncio.wait_for(
+                server.send_message_to_agent(
+                    agent_id=target_agent_id,
+                    actor=sender_agent.user,
+                    messages=messages,
+                    stream_steps=False,
+                    stream_tokens=False,
+                    use_assistant_message=True,
+                    assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
+                    assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
+                ),
+                timeout=timeout,
+            )
+
+            # Extract assistant message
+            assistant_message = parse_letta_response_for_assistant_message(
+                response,
+                assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
+                assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
+            )
+            if assistant_message:
+                msg = f"Agent {target_agent_id} said '{assistant_message}'"
+                sender_agent.logger.info(f"{logging_prefix} - {msg}")
+                return msg
+            else:
+                msg = f"(No response from agent {target_agent_id})"
+                sender_agent.logger.info(f"{logging_prefix} - {msg}")
+                return msg
+        except asyncio.TimeoutError:
+            error_msg = f"(Timeout on attempt {attempt}/{max_retries} for agent {target_agent_id})"
+            sender_agent.logger.warning(f"{logging_prefix} - {error_msg}")
+        except Exception as e:
+            error_msg = f"(Error on attempt {attempt}/{max_retries} for agent {target_agent_id}: {e})"
+            sender_agent.logger.warning(f"{logging_prefix} - {error_msg}")
+
+        # Exponential backoff before retrying
+        if attempt < max_retries:
+            backoff = uniform(0.5, 2) * (2**attempt)
+            sender_agent.logger.warning(f"{logging_prefix} - Retrying the agent to agent send_message...sleeping for {backoff}")
+            await asyncio.sleep(backoff)
+        else:
+            sender_agent.logger.error(f"{logging_prefix} - Fatal error during agent to agent send_message: {error_msg}")
+            return error_msg

letta/functions/schema_generator.py

@@ -1,4 +1,5 @@
 import inspect
+import warnings
 from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
@@ -44,6 +45,13 @@ def type_to_json_schema_type(py_type) -> dict:
     origin = get_origin(py_type)
     if py_type == list or origin in (list, List):
         args = get_args(py_type)
+        if len(args) == 0:
+            # is this correct
+            warnings.warn("Defaulting to string type for untyped List")
+            return {
+                "type": "array",
+                "items": {"type": "string"},
+            }
 
         if args and inspect.isclass(args[0]) and issubclass(args[0], BaseModel):
             # If it's a list of Pydantic models, return an array with the model schema as items

letta/llm_api/openai.py

@@ -307,15 +307,31 @@ def openai_chat_completions_process_stream(
                                 warnings.warn(
                                     f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                 )
+                                # force index 0
+                                # accum_message.tool_calls[0].id = tool_call_delta.id
                             else:
                                 accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
                         if tool_call_delta.function is not None:
                             if tool_call_delta.function.name is not None:
                                 # TODO assert that we're not overwriting?
                                 # TODO += instead of =?
-                                accum_message.tool_calls[tool_call_delta.index].function.name = tool_call_delta.function.name
+                                if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                                    warnings.warn(
+                                        f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
+                                    )
+                                    # force index 0
+                                    # accum_message.tool_calls[0].function.name = tool_call_delta.function.name
+                                else:
+                                    accum_message.tool_calls[tool_call_delta.index].function.name = tool_call_delta.function.name
                             if tool_call_delta.function.arguments is not None:
-                                accum_message.tool_calls[tool_call_delta.index].function.arguments += tool_call_delta.function.arguments
+                                if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                                    warnings.warn(
+                                        f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
+                                    )
+                                    # force index 0
+                                    # accum_message.tool_calls[0].function.arguments += tool_call_delta.function.arguments
+                                else:
+                                    accum_message.tool_calls[tool_call_delta.index].function.arguments += tool_call_delta.function.arguments
 
                 if message_delta.function_call is not None:
                     raise NotImplementedError(f"Old function_call style not support with stream=True")

letta/local_llm/utils.py

@@ -122,6 +122,10 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
                             for o in v["enum"]:
                                 function_tokens += 3
                                 function_tokens += len(encoding.encode(o))
+                        elif field == "items":
+                            function_tokens += 2
+                            if isinstance(v["items"], dict) and "type" in v["items"]:
+                                function_tokens += len(encoding.encode(v["items"]["type"]))
                         else:
                             warnings.warn(f"num_tokens_from_functions: Unsupported field {field} in function {function}")
                 function_tokens += 11

letta/orm/__init__.py

@@ -5,6 +5,7 @@ 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.job_messages import JobMessage
 from letta.orm.message import Message
 from letta.orm.organization import Organization
 from letta.orm.passage import AgentPassage, BasePassage, SourcePassage

letta/orm/enums.py

@@ -5,6 +5,12 @@ class ToolType(str, Enum):
     CUSTOM = "custom"
     LETTA_CORE = "letta_core"
     LETTA_MEMORY_CORE = "letta_memory_core"
+    LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
+
+
+class JobType(str, Enum):
+    JOB = "job"
+    RUN = "run"
 
 
 class ToolSourceType(str, Enum):

letta/orm/job.py

@@ -1,15 +1,20 @@
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from sqlalchemy import JSON, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.orm.enums import JobType
 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
+from letta.schemas.letta_request import LettaRequestConfig
 
 if TYPE_CHECKING:
+    from letta.orm.job_messages import JobMessage
+    from letta.orm.job_usage_statistics import JobUsageStatistics
+    from letta.orm.message import Message
     from letta.orm.user import User
 
 
@@ -23,7 +28,24 @@ class Job(SqlalchemyBase, UserMixin):
 
     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.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, doc="The metadata of the job.")
+    job_type: Mapped[JobType] = mapped_column(
+        String,
+        default=JobType.JOB,
+        doc="The type of job. This affects whether or not we generate json_schema and source_code on the fly.",
+    )
+    request_config: Mapped[Optional[LettaRequestConfig]] = mapped_column(
+        JSON, nullable=True, doc="The request configuration for the job, stored as JSON."
+    )
 
     # relationships
     user: Mapped["User"] = relationship("User", back_populates="jobs")
+    job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")
+    usage_statistics: Mapped[list["JobUsageStatistics"]] = relationship(
+        "JobUsageStatistics", back_populates="job", cascade="all, delete-orphan"
+    )
+
+    @property
+    def messages(self) -> List["Message"]:
+        """Get all messages associated with this job."""
+        return [jm.message for jm in self.job_messages]

letta/orm/job_messages.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+
+if TYPE_CHECKING:
+    from letta.orm.job import Job
+    from letta.orm.message import Message
+
+
+class JobMessage(SqlalchemyBase):
+    """Tracks messages that were created during job execution."""
+
+    __tablename__ = "job_messages"
+    __table_args__ = (UniqueConstraint("job_id", "message_id", name="unique_job_message"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True, doc="Unique identifier for the job message")
+    job_id: Mapped[str] = mapped_column(
+        ForeignKey("jobs.id", ondelete="CASCADE"),
+        nullable=False,  # A job message must belong to a job
+        doc="ID of the job that created the message",
+    )
+    message_id: Mapped[str] = mapped_column(
+        ForeignKey("messages.id", ondelete="CASCADE"),
+        nullable=False,  # A job message must have a message
+        doc="ID of the message created by the job",
+    )
+
+    # Relationships
+    job: Mapped["Job"] = relationship("Job", back_populates="job_messages")
+    message: Mapped["Message"] = relationship("Message", back_populates="job_message")

letta/orm/job_usage_statistics.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+
+if TYPE_CHECKING:
+    from letta.orm.job import Job
+
+
+class JobUsageStatistics(SqlalchemyBase):
+    """Tracks usage statistics for jobs, with future support for per-step tracking."""
+
+    __tablename__ = "job_usage_statistics"
+
+    id: Mapped[int] = mapped_column(primary_key=True, doc="Unique identifier for the usage statistics entry")
+    job_id: Mapped[str] = mapped_column(
+        ForeignKey("jobs.id", ondelete="CASCADE"), nullable=False, doc="ID of the job these statistics belong to"
+    )
+    step_id: Mapped[Optional[str]] = mapped_column(
+        nullable=True, doc="ID of the specific step within the job (for future per-step tracking)"
+    )
+    completion_tokens: Mapped[int] = mapped_column(default=0, doc="Number of tokens generated by the agent")
+    prompt_tokens: Mapped[int] = mapped_column(default=0, doc="Number of tokens in the prompt")
+    total_tokens: Mapped[int] = mapped_column(default=0, doc="Total number of tokens processed by the agent")
+    step_count: Mapped[int] = mapped_column(default=0, doc="Number of steps taken by the agent")
+
+    # Relationship back to the job
+    job: Mapped["Job"] = relationship("Job", back_populates="usage_statistics")

letta/orm/message.py

@@ -28,3 +28,13 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     # Relationships
     agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
     organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")
+
+    # Job relationship
+    job_message: Mapped[Optional["JobMessage"]] = relationship(
+        "JobMessage", back_populates="message", uselist=False, cascade="all, delete-orphan", single_parent=True
+    )
+
+    @property
+    def job(self) -> Optional["Job"]:
+        """Get the job associated with this message, if any."""
+        return self.job_message.job if self.job_message else None

letta/orm/sqlalchemy_base.py

@@ -1,9 +1,9 @@
 from datetime import datetime
 from enum import Enum
 from functools import wraps
-from typing import TYPE_CHECKING, List, Literal, Optional
+from typing import TYPE_CHECKING, List, Literal, Optional, Tuple, Union
 
-from sqlalchemy import String, desc, func, or_, select
+from sqlalchemy import String, and_, desc, func, or_, select
 from sqlalchemy.exc import DBAPIError, IntegrityError, TimeoutError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
@@ -61,6 +61,11 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         ascending: bool = True,
         tags: Optional[List[str]] = None,
         match_all_tags: bool = False,
+        actor: Optional["User"] = None,
+        access: Optional[List[Literal["read", "write", "admin"]]] = ["read"],
+        access_type: AccessType = AccessType.ORGANIZATION,
+        join_model: Optional[Base] = None,
+        join_conditions: Optional[Union[Tuple, List]] = None,
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
@@ -94,6 +99,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             query = select(cls)
 
+            if join_model and join_conditions:
+                query = query.join(join_model, and_(*join_conditions))
+
+            # Apply access predicate if actor is provided
+            if actor:
+                query = cls.apply_access_predicate(query, actor, access, access_type)
+
             # Handle tag filtering if the model has tags
             if tags and hasattr(cls, "tags"):
                 query = select(cls)
@@ -118,7 +130,15 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Apply filtering logic from kwargs
             for key, value in kwargs.items():
-                column = getattr(cls, key)
+                if "." in key:
+                    # Handle joined table columns
+                    table_name, column_name = key.split(".")
+                    joined_table = locals().get(table_name) or globals().get(table_name)
+                    column = getattr(joined_table, column_name)
+                else:
+                    # Handle columns from main table
+                    column = getattr(cls, key)
+
                 if isinstance(value, (list, tuple, set)):
                     query = query.where(column.in_(value))
                 else:
@@ -143,7 +163,11 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
             # Text search
             if query_text:
-                query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
+                if hasattr(cls, "text"):
+                    query = query.filter(func.lower(cls.text).contains(func.lower(query_text)))
+                elif hasattr(cls, "name"):
+                    # Special case for Agent model - search across name
+                    query = query.filter(func.lower(cls.name).contains(func.lower(query_text)))
 
             # Embedding search (for Passages)
             is_ordered = False

letta/orm/tool.py

@@ -40,9 +40,6 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
     source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
     json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
-    module: Mapped[Optional[str]] = mapped_column(
-        String, nullable=True, doc="the module path from which this tool was derived in the codebase."
-    )
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/schemas/agent.py

@@ -95,8 +95,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     name: str = Field(default_factory=lambda: create_random_username(), description="The name of the agent.")
 
     # memory creation
-    memory_blocks: List[CreateBlock] = Field(
-        ...,
+    memory_blocks: Optional[List[CreateBlock]] = Field(
+        None,
         description="The blocks to create in the agent's in-context memory.",
     )
     # TODO: This is a legacy field and should be removed ASAP to force `tool_ids` usage
@@ -115,7 +115,12 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     initial_message_sequence: Optional[List[MessageCreate]] = Field(
         None, description="The initial set of messages to put in the agent's in-context memory."
     )
-    include_base_tools: bool = Field(True, description="The LLM configuration used by the agent.")
+    include_base_tools: bool = Field(
+        True, description="If true, attaches the Letta core tools (e.g. archival_memory and core_memory related functions)."
+    )
+    include_multi_agent_tools: bool = Field(
+        False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
+    )
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
     llm: Optional[str] = Field(
@@ -129,7 +134,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     context_window_limit: Optional[int] = Field(None, description="The context window limit used by the agent.")
     embedding_chunk_size: Optional[int] = Field(DEFAULT_EMBEDDING_CHUNK_SIZE, description="The embedding chunk size used by the agent.")
     from_template: Optional[str] = Field(None, description="The template id used to configure the agent")
-    project_id: Optional[str] = Field(None, description="The project id that the agent will be associated with.")
+    template: bool = Field(False, description="Whether the agent is a template")
+    project: Optional[str] = Field(None, description="The project slug that the agent will be associated with.")
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )

letta/schemas/job.py

@@ -3,6 +3,7 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.orm.enums import JobType
 from letta.schemas.enums import JobStatus
 from letta.schemas.letta_base import OrmMetadataBase
 
@@ -12,6 +13,7 @@ class JobBase(OrmMetadataBase):
     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.")
+    job_type: JobType = Field(default=JobType.JOB, description="The type of the job.")
 
 
 class Job(JobBase):

letta/schemas/letta_base.py

@@ -52,8 +52,13 @@ class LettaBase(BaseModel):
     @classmethod
     def _id_regex_pattern(cls, prefix: str):
         """generates the regex pattern for a given id"""
+        if cls.__name__ in ("JobBase", "Job", "Run", "RunBase"):
+            prefix_pattern = "(job|run)"
+        else:
+            prefix_pattern = prefix
+
         return (
-            r"^" + prefix + r"-"  # prefix string
+            r"^" + prefix_pattern + r"-"  # prefix string
             r"[a-fA-F0-9]{8}"  # 8 hexadecimal characters
             # r"[a-fA-F0-9]{4}-"  # 4 hexadecimal characters
             # r"[a-fA-F0-9]{4}-"  # 4 hexadecimal characters

letta/schemas/letta_request.py

@@ -6,11 +6,8 @@ from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.message import MessageCreate
 
 
-class LettaRequest(BaseModel):
-    messages: List[MessageCreate] = Field(..., description="The messages to be sent to the agent.")
-
+class LettaRequestConfig(BaseModel):
     # Flags to support the use of AssistantMessage message types
-
     use_assistant_message: bool = Field(
         default=True,
         description="Whether the server should parse specific tool call arguments (default `send_message`) as `AssistantMessage` objects.",
@@ -25,6 +22,11 @@ class LettaRequest(BaseModel):
     )
 
 
+class LettaRequest(BaseModel):
+    messages: List[MessageCreate] = Field(..., description="The messages to be sent to the agent.")
+    config: LettaRequestConfig = Field(default=LettaRequestConfig(), description="Configuration options for the LettaRequest.")
+
+
 class LettaStreamingRequest(LettaRequest):
     stream_tokens: bool = Field(
         default=False,

letta/schemas/llm_config.py

@@ -96,7 +96,7 @@ class LLMConfig(BaseModel):
                 model="memgpt-openai",
                 model_endpoint_type="openai",
                 model_endpoint="https://inference.memgpt.ai",
-                context_window=16384,
+                context_window=8192,
             )
         else:
             raise ValueError(f"Model {model_name} not supported.")

letta/schemas/message.py

@@ -149,9 +149,9 @@ class Message(BaseMessage):
                         # We need to unpack the actual message contents from the function call
                         try:
                             func_args = json.loads(tool_call.function.arguments)
-                            message_string = func_args[DEFAULT_MESSAGE_TOOL_KWARG]
+                            message_string = func_args[assistant_message_tool_kwarg]
                         except KeyError:
-                            raise ValueError(f"Function call {tool_call.function.name} missing {DEFAULT_MESSAGE_TOOL_KWARG} argument")
+                            raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
                         messages.append(
                             AssistantMessage(
                                 id=self.id,
@@ -708,8 +708,6 @@ class Message(BaseMessage):
                     },
                 ]
                 for tc in self.tool_calls:
-                    # TODO better way to pack?
-                    # function_call_text = json.dumps(tc.to_dict())
                     function_name = tc.function["name"]
                     function_args = json.loads(tc.function["arguments"])
                     function_args_str = ",".join([f"{k}={v}" for k, v in function_args.items()])

letta/schemas/providers.py

@@ -63,7 +63,7 @@ class LettaProvider(Provider):
                 model="letta-free",  # NOTE: renamed
                 model_endpoint_type="openai",
                 model_endpoint="https://inference.memgpt.ai",
-                context_window=16384,
+                context_window=8192,
                 handle=self.get_handle("letta-free"),
             )
         ]

letta/schemas/run.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+from pydantic import Field
+
+from letta.orm.enums import JobType
+from letta.schemas.job import Job, JobBase
+from letta.schemas.letta_request import LettaRequestConfig
+
+
+class RunBase(JobBase):
+    """Base class for Run schemas that inherits from JobBase but uses 'run' prefix for IDs"""
+
+    __id_prefix__ = "run"
+    job_type: JobType = JobType.RUN
+
+
+class Run(RunBase):
+    """
+    Representation of a run, which is a job with a 'run' prefix in its ID.
+    Inherits all fields and behavior from Job except for the ID prefix.
+
+    Parameters:
+        id (str): The unique identifier of the run (prefixed with 'run-').
+        status (JobStatus): The status of the run.
+        created_at (datetime): The unix timestamp of when the run was created.
+        completed_at (datetime): The unix timestamp of when the run was completed.
+        user_id (str): The unique identifier of the user associated with the run.
+    """
+
+    id: str = RunBase.generate_id_field()
+    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the run.")
+    request_config: Optional[LettaRequestConfig] = Field(None, description="The request configuration for the run.")
+
+    @classmethod
+    def from_job(cls, job: Job) -> "Run":
+        """
+        Convert a Job instance to a Run instance by replacing the ID prefix.
+        All other fields are copied as-is.
+
+        Args:
+            job: The Job instance to convert
+
+        Returns:
+            A new Run instance with the same data but 'run-' prefix in ID
+        """
+        # Convert job dict to exclude None values
+        job_data = job.model_dump(exclude_none=True)
+
+        # Create new Run instance with converted data
+        return cls(**job_data)
+
+    def to_job(self) -> Job:
+        """
+        Convert this Run instance to a Job instance by replacing the ID prefix.
+        All other fields are copied as-is.
+
+        Returns:
+            A new Job instance with the same data but 'job-' prefix in ID
+        """
+        run_data = self.model_dump(exclude_none=True)
+        return Job(**run_data)