letta-nightly 0.6.16.dev20250128104041__py3-none-any.whl → 0.6.17.dev20250129174639__py3-none-any.whl

letta/llm_api/openai.py

@@ -1,8 +1,8 @@
 import warnings
-from typing import Generator, List, Optional, Union
+from typing import AsyncGenerator, List, Optional, Union
 
 import requests
-from openai import OpenAI
+from openai import AsyncOpenAI
 
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_structured_output, make_post_request
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
@@ -158,7 +158,7 @@ def build_openai_chat_completions_request(
     return data
 
 
-def openai_chat_completions_process_stream(
+async def openai_chat_completions_process_stream(
     url: str,
     api_key: str,
     chat_completion_request: ChatCompletionRequest,
@@ -229,9 +229,10 @@ def openai_chat_completions_process_stream(
         stream_interface.stream_start()
 
     n_chunks = 0  # approx == n_tokens
+    chunk_idx = 0
     try:
-        for chunk_idx, chat_completion_chunk in enumerate(
-            openai_chat_completions_request_stream(url=url, api_key=api_key, chat_completion_request=chat_completion_request)
+        async for chat_completion_chunk in openai_chat_completions_request_stream(
+            url=url, api_key=api_key, chat_completion_request=chat_completion_request
         ):
             assert isinstance(chat_completion_chunk, ChatCompletionChunkResponse), type(chat_completion_chunk)
 
@@ -348,6 +349,7 @@ def openai_chat_completions_process_stream(
 
             # increment chunk counter
             n_chunks += 1
+            chunk_idx += 1
 
     except Exception as e:
         if stream_interface:
@@ -380,24 +382,24 @@ def openai_chat_completions_process_stream(
     return chat_completion_response
 
 
-def openai_chat_completions_request_stream(
+async def openai_chat_completions_request_stream(
     url: str,
     api_key: str,
     chat_completion_request: ChatCompletionRequest,
-) -> Generator[ChatCompletionChunkResponse, None, None]:
+) -> AsyncGenerator[ChatCompletionChunkResponse, None]:
     data = prepare_openai_payload(chat_completion_request)
     data["stream"] = True
-    client = OpenAI(
+    client = AsyncOpenAI(
         api_key=api_key,
         base_url=url,
     )
-    stream = client.chat.completions.create(**data)
-    for chunk in stream:
+    stream = await client.chat.completions.create(**data)
+    async for chunk in stream:
         # TODO: Use the native OpenAI objects here?
         yield ChatCompletionChunkResponse(**chunk.model_dump(exclude_none=True))
 
 
-def openai_chat_completions_request(
+async def openai_chat_completions_request(
     url: str,
     api_key: str,
     chat_completion_request: ChatCompletionRequest,
@@ -410,8 +412,8 @@ def openai_chat_completions_request(
     https://platform.openai.com/docs/guides/text-generation?lang=curl
     """
     data = prepare_openai_payload(chat_completion_request)
-    client = OpenAI(api_key=api_key, base_url=url)
-    chat_completion = client.chat.completions.create(**data)
+    client = AsyncOpenAI(api_key=api_key, base_url=url)
+    chat_completion = await client.chat.completions.create(**data)
     return ChatCompletionResponse(**chat_completion.model_dump())
 
 

letta/orm/agent.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, List, Optional
 from sqlalchemy import JSON, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.constants import MULTI_AGENT_TOOLS
 from letta.orm.block import Block
 from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ToolRulesColumn
 from letta.orm.message import Message
@@ -15,7 +16,7 @@ from letta.schemas.agent import AgentType
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
-from letta.schemas.tool_rule import ToolRule
+from letta.schemas.tool_rule import TerminalToolRule, ToolRule
 
 if TYPE_CHECKING:
     from letta.orm.agents_tags import AgentsTags
@@ -114,6 +115,16 @@ class Agent(SqlalchemyBase, OrganizationMixin):
 
     def to_pydantic(self) -> PydanticAgentState:
         """converts to the basic pydantic model counterpart"""
+        # add default rule for having send_message be a terminal tool
+        tool_rules = self.tool_rules
+        if not tool_rules:
+            tool_rules = [
+                TerminalToolRule(tool_name="send_message"),
+            ]
+
+            for tool_name in MULTI_AGENT_TOOLS:
+                tool_rules.append(TerminalToolRule(tool_name=tool_name))
+
         state = {
             "id": self.id,
             "organization_id": self.organization_id,
@@ -123,7 +134,7 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "tools": self.tools,
             "sources": [source.to_pydantic() for source in self.sources],
             "tags": [t.tag for t in self.tags],
-            "tool_rules": self.tool_rules,
+            "tool_rules": tool_rules,
             "system": self.system,
             "agent_type": self.agent_type,
             "llm_config": self.llm_config,
@@ -136,4 +147,5 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "updated_at": self.updated_at,
             "tool_exec_environment_variables": self.tool_exec_environment_variables,
         }
+
         return self.__pydantic_model__(**state)

letta/orm/job.py

@@ -9,7 +9,7 @@ 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
+from letta.schemas.job import LettaRequestConfig
 
 if TYPE_CHECKING:
     from letta.orm.job_messages import JobMessage

letta/orm/sqlalchemy_base.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 from enum import Enum
 from functools import wraps
+from pprint import pformat
 from typing import TYPE_CHECKING, List, Literal, Optional, Tuple, Union
 
 from sqlalchemy import String, and_, func, or_, select
@@ -504,7 +505,14 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             model.metadata = self.metadata_
         return model
 
-    def to_record(self) -> "BaseModel":
-        """Deprecated accessor for to_pydantic"""
-        logger.warning("to_record is deprecated, use to_pydantic instead.")
-        return self.to_pydantic()
+    def pretty_print_columns(self) -> str:
+        """
+        Pretty prints all columns of the current SQLAlchemy object along with their values.
+        """
+        if not hasattr(self, "__table__") or not hasattr(self.__table__, "columns"):
+            raise NotImplementedError("This object does not have a '__table__.columns' attribute.")
+
+        # Iterate over the columns correctly
+        column_data = {column.name: getattr(self, column.name, None) for column in self.__table__.columns}
+
+        return pformat(column_data, indent=4, sort_dicts=True)

letta/schemas/job.py

@@ -1,8 +1,9 @@
 from datetime import datetime
 from typing import Optional
 
-from pydantic import Field
+from pydantic import BaseModel, Field
 
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.orm.enums import JobType
 from letta.schemas.enums import JobStatus
 from letta.schemas.letta_base import OrmMetadataBase
@@ -38,3 +39,18 @@ class JobUpdate(JobBase):
 
     class Config:
         extra = "ignore"  # Ignores extra fields
+
+
+class LettaRequestConfig(BaseModel):
+    use_assistant_message: bool = Field(
+        default=True,
+        description="Whether the server should parse specific tool call arguments (default `send_message`) as `AssistantMessage` objects.",
+    )
+    assistant_message_tool_name: str = Field(
+        default=DEFAULT_MESSAGE_TOOL,
+        description="The name of the designated message tool.",
+    )
+    assistant_message_tool_kwarg: str = Field(
+        default=DEFAULT_MESSAGE_TOOL_KWARG,
+        description="The name of the message argument in the designated message tool.",
+    )

letta/schemas/letta_request.py

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

@@ -88,6 +88,7 @@ class LLMConfig(BaseModel):
                 model_endpoint="https://api.openai.com/v1",
                 model_wrapper=None,
                 context_window=8192,
+                put_inner_thoughts_in_kwargs=True,
             )
         elif model_name == "gpt-4o-mini":
             return cls(
@@ -97,6 +98,14 @@ class LLMConfig(BaseModel):
                 model_wrapper=None,
                 context_window=128000,
             )
+        elif model_name == "gpt-4o":
+            return cls(
+                model="gpt-4o",
+                model_endpoint_type="openai",
+                model_endpoint="https://api.openai.com/v1",
+                model_wrapper=None,
+                context_window=128000,
+            )
         elif model_name == "letta":
             return cls(
                 model="memgpt-openai",

letta/schemas/message.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import copy
 import json
 import warnings
@@ -25,6 +27,7 @@ from letta.schemas.letta_message import (
     ToolReturnMessage,
     UserMessage,
 )
+from letta.system import unpack_message
 from letta.utils import get_utc_time, is_utc_datetime, json_dumps
 
 
@@ -176,9 +179,47 @@ class Message(BaseMessage):
         json_message["created_at"] = self.created_at.isoformat()
         return json_message
 
+    @staticmethod
+    def to_letta_messages_from_list(
+        messages: List[Message],
+        use_assistant_message: bool = True,
+        assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
+        assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
+    ) -> List[LettaMessage]:
+        if use_assistant_message:
+            message_ids_to_remove = []
+            assistant_messages_by_tool_call = {
+                tool_call.id: msg
+                for msg in messages
+                if msg.role == MessageRole.assistant and msg.tool_calls
+                for tool_call in msg.tool_calls
+            }
+            for message in messages:
+                if (
+                    message.role == MessageRole.tool
+                    and message.tool_call_id in assistant_messages_by_tool_call
+                    and assistant_messages_by_tool_call[message.tool_call_id].tool_calls
+                    and assistant_message_tool_name
+                    in [tool_call.function.name for tool_call in assistant_messages_by_tool_call[message.tool_call_id].tool_calls]
+                ):
+                    message_ids_to_remove.append(message.id)
+
+            messages = [msg for msg in messages if msg.id not in message_ids_to_remove]
+
+        # Convert messages to LettaMessages
+        return [
+            msg
+            for m in messages
+            for msg in m.to_letta_message(
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+            )
+        ]
+
     def to_letta_message(
         self,
-        assistant_message: bool = False,
+        use_assistant_message: bool = False,
         assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> List[LettaMessage]:
@@ -201,7 +242,7 @@ class Message(BaseMessage):
                 for tool_call in self.tool_calls:
                     # If we're supporting using assistant message,
                     # then we want to treat certain function calls as a special case
-                    if assistant_message and tool_call.function.name == assistant_message_tool_name:
+                    if use_assistant_message and tool_call.function.name == assistant_message_tool_name:
                         # We need to unpack the actual message contents from the function call
                         try:
                             func_args = json.loads(tool_call.function.arguments)
@@ -264,11 +305,12 @@ class Message(BaseMessage):
         elif self.role == MessageRole.user:
             # This is type UserMessage
             assert self.text is not None, self
+            message_str = unpack_message(self.text)
             messages.append(
                 UserMessage(
                     id=self.id,
                     date=self.created_at,
-                    content=self.text,
+                    content=message_str or self.text,
                 )
             )
         elif self.role == MessageRole.system:
@@ -311,26 +353,13 @@ class Message(BaseMessage):
             assert "tool_call_id" in openai_message_dict, openai_message_dict
 
             # Convert from 'function' response to a 'tool' response
-            # NOTE: this does not conventionally include a tool_call_id, it's on the caster to provide it
-            message_args = dict(
-                user_id=user_id,
-                agent_id=agent_id,
-                model=model,
-                # standard fields expected in an OpenAI ChatCompletion message object
-                role=MessageRole.tool,  # NOTE
-                text=openai_message_dict["content"],
-                name=openai_message_dict["name"] if "name" in openai_message_dict else None,
-                tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
-                tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
-                created_at=created_at,
-            )
             if id is not None:
                 return Message(
                     agent_id=agent_id,
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    content=[TextContent(text=openai_message_dict["content"])],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -343,7 +372,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    content=[TextContent(text=openai_message_dict["content"])],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -375,7 +404,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -388,7 +417,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -420,7 +449,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -433,7 +462,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"] or "")],
+                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,

letta/schemas/openai/chat_completion_response.py

@@ -116,7 +116,7 @@ class MessageDelta(BaseModel):
 
     content: Optional[str] = None
     tool_calls: Optional[List[ToolCallDelta]] = None
-    # role: Optional[str] = None
+    role: Optional[str] = None
     function_call: Optional[FunctionCallDelta] = None  # Deprecated
 
 
@@ -132,7 +132,7 @@ class ChatCompletionChunkResponse(BaseModel):
 
     id: str
     choices: List[ChunkChoice]
-    created: datetime.datetime
+    created: Union[datetime.datetime, str]
     model: str
     # system_fingerprint: str  # docs say this is mandatory, but in reality API returns None
     system_fingerprint: Optional[str] = None

letta/schemas/run.py

@@ -3,8 +3,7 @@ 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
+from letta.schemas.job import Job, JobBase, LettaRequestConfig
 
 
 class RunBase(JobBase):

letta/server/rest_api/app.py

@@ -12,7 +12,7 @@ from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__
-from letta.constants import ADMIN_PREFIX, API_PREFIX
+from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
 from letta.log import get_logger
 from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
@@ -22,6 +22,7 @@ from letta.server.constants import REST_DEFAULT_PORT
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
 from letta.server.rest_api.auth.index import setup_auth_router  # TODO: probably remove right?
 from letta.server.rest_api.interface import StreamingServerInterface
+from letta.server.rest_api.routers.openai.chat_completions.chat_completions import router as openai_chat_completions_router
 
 # from letta.orm.utilities import get_db_session  # TODO(ethan) reenable once we merge ORM
 from letta.server.rest_api.routers.v1 import ROUTERS as v1_routes
@@ -241,6 +242,9 @@ def create_application() -> "FastAPI":
     app.include_router(users_router, prefix=ADMIN_PREFIX)
     app.include_router(organizations_router, prefix=ADMIN_PREFIX)
 
+    # openai
+    app.include_router(openai_chat_completions_router, prefix=OPENAI_API_PREFIX)
+
     # /api/auth endpoints
     app.include_router(setup_auth_router(server, interface, password), prefix=API_PREFIX)