letta-nightly 0.7.1.dev20250423104245__tar.gz → 0.7.2.dev20250423222439__tar.gz

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/PKG-INFO

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

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.1"
+__version__ = "0.7.2"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/helpers/composio_helpers.py

@@ -10,7 +10,7 @@ def get_composio_api_key(actor: User, logger: Optional[Logger] = None) -> Option
     api_keys = SandboxConfigManager().list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
     if not api_keys:
         if logger:
-            logger.warning(f"No API keys found for Composio. Defaulting to the environment variable...")
+            logger.debug(f"No API keys found for Composio. Defaulting to the environment variable...")
         if tool_settings.composio_api_key:
             return tool_settings.composio_api_key
         else:

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/helpers/datetime_helpers.py

@@ -66,6 +66,15 @@ def get_utc_time() -> datetime:
     return datetime.now(timezone.utc)
 
 
+def get_utc_time_int() -> int:
+    return int(get_utc_time().timestamp())
+
+
+def timestamp_to_datetime(timestamp_seconds: int) -> datetime:
+    """Convert Unix timestamp in seconds to UTC datetime object"""
+    return datetime.fromtimestamp(timestamp_seconds, tz=timezone.utc)
+
+
 def format_datetime(dt):
     return dt.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
 

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/jobs/llm_batch_job_polling.py

@@ -73,7 +73,8 @@ async def fetch_batch_items(server: SyncServer, batch_id: str, batch_resp_id: st
     """
     updates = []
     try:
-        async for item_result in server.anthropic_async_client.beta.messages.batches.results(batch_resp_id):
+        results = await server.anthropic_async_client.beta.messages.batches.results(batch_resp_id)
+        async for item_result in results:
             # Here, custom_id should be the agent_id
             item_status = map_anthropic_individual_batch_item_status_to_job_status(item_result)
             updates.append(ItemUpdateInfo(batch_id, item_result.custom_id, item_status, item_result))

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/anthropic.py

@@ -20,7 +20,7 @@ from anthropic.types.beta import (
 )
 
 from letta.errors import BedrockError, BedrockPermissionError
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int, timestamp_to_datetime
 from letta.llm_api.aws_bedrock import get_bedrock_client
 from letta.llm_api.helpers import add_inner_thoughts_to_functions
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
@@ -396,7 +396,7 @@ def convert_anthropic_response_to_chatcompletion(
     return ChatCompletionResponse(
         id=response.id,
         choices=[choice],
-        created=get_utc_time(),
+        created=get_utc_time_int(),
         model=response.model,
         usage=UsageStatistics(
             prompt_tokens=prompt_tokens,
@@ -451,7 +451,7 @@ def convert_anthropic_stream_event_to_chatcompletion(
                 'logprobs': None
             }
         ],
-        'created': datetime.datetime(2025, 1, 24, 0, 18, 55, tzinfo=TzInfo(UTC)),
+        'created': 1713216662,
         'model': 'gpt-4o-mini-2024-07-18',
         'system_fingerprint': 'fp_bd83329f63',
         'object': 'chat.completion.chunk'
@@ -613,7 +613,7 @@ def convert_anthropic_stream_event_to_chatcompletion(
     return ChatCompletionChunkResponse(
         id=message_id,
         choices=[choice],
-        created=get_utc_time(),
+        created=get_utc_time_int(),
         model=model,
         output_tokens=completion_chunk_tokens,
     )
@@ -920,7 +920,7 @@ def anthropic_chat_completions_process_stream(
     chat_completion_response = ChatCompletionResponse(
         id=dummy_message.id if create_message_id else TEMP_STREAM_RESPONSE_ID,
         choices=[],
-        created=dummy_message.created_at,
+        created=int(dummy_message.created_at.timestamp()),
         model=chat_completion_request.model,
         usage=UsageStatistics(
             prompt_tokens=prompt_tokens,
@@ -954,7 +954,11 @@ def anthropic_chat_completions_process_stream(
                     message_type = stream_interface.process_chunk(
                         chat_completion_chunk,
                         message_id=chat_completion_response.id if create_message_id else chat_completion_chunk.id,
-                        message_date=chat_completion_response.created if create_message_datetime else chat_completion_chunk.created,
+                        message_date=(
+                            timestamp_to_datetime(chat_completion_response.created)
+                            if create_message_datetime
+                            else timestamp_to_datetime(chat_completion_chunk.created)
+                        ),
                         # if extended_thinking is on, then reasoning_content will be flowing as chunks
                         # TODO handle emitting redacted reasoning content (e.g. as concat?)
                         expect_reasoning_content=extended_thinking,

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/anthropic_client.py

@@ -22,7 +22,7 @@ from letta.errors import (
     LLMServerError,
     LLMUnprocessableEntityError,
 )
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_inner_thoughts_from_kwargs
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
@@ -403,7 +403,7 @@ class AnthropicClient(LLMClientBase):
         chat_completion_response = ChatCompletionResponse(
             id=response.id,
             choices=[choice],
-            created=get_utc_time(),
+            created=get_utc_time_int(),
             model=response.model,
             usage=UsageStatistics(
                 prompt_tokens=prompt_tokens,

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/cohere.py

@@ -4,7 +4,7 @@ from typing import List, Optional, Union
 
 import requests
 
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.utils import count_tokens
 from letta.schemas.message import Message
@@ -207,7 +207,7 @@ def convert_cohere_response_to_chatcompletion(
     return ChatCompletionResponse(
         id=response_json["response_id"],
         choices=[choice],
-        created=get_utc_time(),
+        created=get_utc_time_int(),
         model=model,
         usage=UsageStatistics(
             prompt_tokens=prompt_tokens,

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/google_ai_client.py

@@ -6,7 +6,7 @@ import requests
 from google.genai.types import FunctionCallingConfig, FunctionCallingConfigMode, ToolConfig
 
 from letta.constants import NON_USER_MSG_PREFIX
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.helpers.json_helpers import json_dumps
 from letta.llm_api.helpers import make_post_request
 from letta.llm_api.llm_client_base import LLMClientBase
@@ -260,7 +260,7 @@ class GoogleAIClient(LLMClientBase):
                 id=response_id,
                 choices=choices,
                 model=self.llm_config.model,  # NOTE: Google API doesn't pass back model in the response
-                created=get_utc_time(),
+                created=get_utc_time_int(),
                 usage=usage,
             )
         except KeyError as e:

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/google_vertex_client.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 from google import genai
 from google.genai.types import FunctionCallingConfig, FunctionCallingConfigMode, GenerateContentResponse, ThinkingConfig, ToolConfig
 
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.helpers.json_helpers import json_dumps
 from letta.llm_api.google_ai_client import GoogleAIClient
 from letta.local_llm.json_parser import clean_json_string_extra_backslash
@@ -234,7 +234,7 @@ class GoogleVertexClient(GoogleAIClient):
                 id=response_id,
                 choices=choices,
                 model=self.llm_config.model,  # NOTE: Google API doesn't pass back model in the response
-                created=get_utc_time(),
+                created=get_utc_time_int(),
                 usage=usage,
             )
         except KeyError as e:

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/openai.py

@@ -4,7 +4,9 @@ from typing import Generator, List, Optional, Union
 import requests
 from openai import OpenAI
 
+from letta.helpers.datetime_helpers import timestamp_to_datetime
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_structured_output, make_post_request
+from letta.llm_api.openai_client import supports_parallel_tool_calling, supports_temperature_param
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.log import get_logger
@@ -135,7 +137,7 @@ def build_openai_chat_completions_request(
             tool_choice=tool_choice,
             user=str(user_id),
             max_completion_tokens=llm_config.max_tokens,
-            temperature=1.0 if llm_config.enable_reasoner else llm_config.temperature,
+            temperature=llm_config.temperature if supports_temperature_param(model) else None,
             reasoning_effort=llm_config.reasoning_effort,
         )
     else:
@@ -237,7 +239,7 @@ def openai_chat_completions_process_stream(
     chat_completion_response = ChatCompletionResponse(
         id=dummy_message.id if create_message_id else TEMP_STREAM_RESPONSE_ID,
         choices=[],
-        created=dummy_message.created_at,  # NOTE: doesn't matter since both will do get_utc_time()
+        created=int(dummy_message.created_at.timestamp()),  # NOTE: doesn't matter since both will do get_utc_time()
         model=chat_completion_request.model,
         usage=UsageStatistics(
             completion_tokens=0,
@@ -274,7 +276,11 @@ def openai_chat_completions_process_stream(
                     message_type = stream_interface.process_chunk(
                         chat_completion_chunk,
                         message_id=chat_completion_response.id if create_message_id else chat_completion_chunk.id,
-                        message_date=chat_completion_response.created if create_message_datetime else chat_completion_chunk.created,
+                        message_date=(
+                            timestamp_to_datetime(chat_completion_response.created)
+                            if create_message_datetime
+                            else timestamp_to_datetime(chat_completion_chunk.created)
+                        ),
                         expect_reasoning_content=expect_reasoning_content,
                         name=name,
                         message_index=message_idx,
@@ -489,6 +495,7 @@ def prepare_openai_payload(chat_completion_request: ChatCompletionRequest):
     #         except ValueError as e:
     #             warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
-    if "o3-mini" in chat_completion_request.model or "o1" in chat_completion_request.model:
+    if not supports_parallel_tool_calling(chat_completion_request.model):
         data.pop("parallel_tool_calls", None)
+
     return data

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/llm_api/openai_client.py

@@ -34,6 +34,33 @@ from letta.settings import model_settings
 logger = get_logger(__name__)
 
 
+def is_openai_reasoning_model(model: str) -> bool:
+    """Utility function to check if the model is a 'reasoner'"""
+
+    # NOTE: needs to be updated with new model releases
+    return model.startswith("o1") or model.startswith("o3")
+
+
+def supports_temperature_param(model: str) -> bool:
+    """Certain OpenAI models don't support configuring the temperature.
+
+    Example error: 400 - {'error': {'message': "Unsupported parameter: 'temperature' is not supported with this model.", 'type': 'invalid_request_error', 'param': 'temperature', 'code': 'unsupported_parameter'}}
+    """
+    if is_openai_reasoning_model(model):
+        return False
+    else:
+        return True
+
+
+def supports_parallel_tool_calling(model: str) -> bool:
+    """Certain OpenAI models don't support parallel tool calls."""
+
+    if is_openai_reasoning_model(model):
+        return False
+    else:
+        return True
+
+
 class OpenAIClient(LLMClientBase):
     def _prepare_client_kwargs(self) -> dict:
         api_key = model_settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
@@ -66,7 +93,8 @@ class OpenAIClient(LLMClientBase):
                 put_inner_thoughts_first=True,
             )
 
-        use_developer_message = llm_config.model.startswith("o1") or llm_config.model.startswith("o3")  # o-series models
+        use_developer_message = is_openai_reasoning_model(llm_config.model)
+
         openai_message_list = [
             cast_message_to_subtype(
                 m.to_openai_dict(
@@ -103,7 +131,7 @@ class OpenAIClient(LLMClientBase):
             tool_choice=tool_choice,
             user=str(),
             max_completion_tokens=llm_config.max_tokens,
-            temperature=llm_config.temperature,
+            temperature=llm_config.temperature if supports_temperature_param(model) else None,
         )
 
         if "inference.memgpt.ai" in llm_config.model_endpoint:
@@ -160,6 +188,10 @@ class OpenAIClient(LLMClientBase):
                 response=chat_completion_response, inner_thoughts_key=INNER_THOUGHTS_KWARG
             )
 
+        # If we used a reasoning model, create a content part for the ommitted reasoning
+        if is_openai_reasoning_model(self.llm_config.model):
+            chat_completion_response.choices[0].message.ommitted_reasoning_content = True
+
         return chat_completion_response
 
     def stream(self, request_data: dict) -> Stream[ChatCompletionChunk]:

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/local_llm/chat_completion_proxy.py

@@ -6,7 +6,7 @@ import requests
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LocalLLMConnectionError, LocalLLMError
-from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.constants import DEFAULT_WRAPPER
 from letta.local_llm.function_parser import patch_function
@@ -241,7 +241,7 @@ def get_chat_completion(
                 ),
             )
         ],
-        created=get_utc_time(),
+        created=get_utc_time_int(),
         model=model,
         # "This fingerprint represents the backend configuration that the model runs with."
         # system_fingerprint=user if user is not None else "null",

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/schemas/letta_message_content.py

@@ -145,7 +145,8 @@ class OmittedReasoningContent(MessageContent):
     type: Literal[MessageContentType.omitted_reasoning] = Field(
         MessageContentType.omitted_reasoning, description="Indicates this is an omitted reasoning step."
     )
-    tokens: int = Field(..., description="The reasoning token count for intermediate reasoning content.")
+    # NOTE: dropping because we don't track this kind of information for the other reasoning types
+    # tokens: int = Field(..., description="The reasoning token count for intermediate reasoning content.")
 
 
 LettaMessageContentUnion = Annotated[

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/schemas/llm_config.py

@@ -81,8 +81,11 @@ class LLMConfig(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def set_default_enable_reasoner(cls, values):
-        if any(openai_reasoner_model in values.get("model", "") for openai_reasoner_model in ["o3-mini", "o1"]):
-            values["enable_reasoner"] = True
+        # NOTE: this is really only applicable for models that can toggle reasoning on-and-off, like 3.7
+        # We can also use this field to identify if a model is a "reasoning" model (o1/o3, etc.) if we want
+        # if any(openai_reasoner_model in values.get("model", "") for openai_reasoner_model in ["o3-mini", "o1"]):
+        #     values["enable_reasoner"] = True
+        #     values["put_inner_thoughts_in_kwargs"] = False
         return values
 
     @model_validator(mode="before")
@@ -100,6 +103,13 @@ class LLMConfig(BaseModel):
         if values.get("put_inner_thoughts_in_kwargs") is None:
             values["put_inner_thoughts_in_kwargs"] = False if model in avoid_put_inner_thoughts_in_kwargs else True
 
+        # For the o1/o3 series from OpenAI, set to False by default
+        # We can set this flag to `true` if desired, which will enable "double-think"
+        from letta.llm_api.openai_client import is_openai_reasoning_model
+
+        if is_openai_reasoning_model(model):
+            values["put_inner_thoughts_in_kwargs"] = False
+
         return values
 
     @model_validator(mode="after")

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/schemas/message.py

@@ -31,6 +31,7 @@ from letta.schemas.letta_message import (
 )
 from letta.schemas.letta_message_content import (
     LettaMessageContentUnion,
+    OmittedReasoningContent,
     ReasoningContent,
     RedactedReasoningContent,
     TextContent,
@@ -295,6 +296,18 @@ class Message(BaseMessage):
                                     sender_id=self.sender_id,
                                 )
                             )
+                        elif isinstance(content_part, OmittedReasoningContent):
+                            # Special case for "hidden reasoning" models like o1/o3
+                            # NOTE: we also have to think about how to return this during streaming
+                            messages.append(
+                                HiddenReasoningMessage(
+                                    id=self.id,
+                                    date=self.created_at,
+                                    state="omitted",
+                                    name=self.name,
+                                    otid=otid,
+                                )
+                            )
                         else:
                             warnings.warn(f"Unrecognized content part in assistant message: {content_part}")
 
@@ -464,6 +477,10 @@ class Message(BaseMessage):
                     data=openai_message_dict["redacted_reasoning_content"] if "redacted_reasoning_content" in openai_message_dict else None,
                 ),
             )
+        if "omitted_reasoning_content" in openai_message_dict and openai_message_dict["omitted_reasoning_content"]:
+            content.append(
+                OmittedReasoningContent(),
+            )
 
         # If we're going from deprecated function form
         if openai_message_dict["role"] == "function":

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/schemas/openai/chat_completion_response.py

@@ -39,9 +39,10 @@ class Message(BaseModel):
     tool_calls: Optional[List[ToolCall]] = None
     role: str
     function_call: Optional[FunctionCall] = None  # Deprecated
-    reasoning_content: Optional[str] = None  # Used in newer reasoning APIs
+    reasoning_content: Optional[str] = None  # Used in newer reasoning APIs, e.g. DeepSeek
     reasoning_content_signature: Optional[str] = None  # NOTE: for Anthropic
     redacted_reasoning_content: Optional[str] = None  # NOTE: for Anthropic
+    ommitted_reasoning_content: bool = False  # NOTE: for OpenAI o1/o3
 
 
 class Choice(BaseModel):
@@ -52,16 +53,64 @@ class Choice(BaseModel):
     seed: Optional[int] = None  # found in TogetherAI
 
 
+class UsageStatisticsPromptTokenDetails(BaseModel):
+    cached_tokens: int = 0
+    # NOTE: OAI specific
+    # audio_tokens: int = 0
+
+    def __add__(self, other: "UsageStatisticsPromptTokenDetails") -> "UsageStatisticsPromptTokenDetails":
+        return UsageStatisticsPromptTokenDetails(
+            cached_tokens=self.cached_tokens + other.cached_tokens,
+        )
+
+
+class UsageStatisticsCompletionTokenDetails(BaseModel):
+    reasoning_tokens: int = 0
+    # NOTE: OAI specific
+    # audio_tokens: int = 0
+    # accepted_prediction_tokens: int = 0
+    # rejected_prediction_tokens: int = 0
+
+    def __add__(self, other: "UsageStatisticsCompletionTokenDetails") -> "UsageStatisticsCompletionTokenDetails":
+        return UsageStatisticsCompletionTokenDetails(
+            reasoning_tokens=self.reasoning_tokens + other.reasoning_tokens,
+        )
+
+
 class UsageStatistics(BaseModel):
     completion_tokens: int = 0
     prompt_tokens: int = 0
     total_tokens: int = 0
 
+    prompt_tokens_details: Optional[UsageStatisticsPromptTokenDetails] = None
+    completion_tokens_details: Optional[UsageStatisticsCompletionTokenDetails] = None
+
     def __add__(self, other: "UsageStatistics") -> "UsageStatistics":
+
+        if self.prompt_tokens_details is None and other.prompt_tokens_details is None:
+            total_prompt_tokens_details = None
+        elif self.prompt_tokens_details is None:
+            total_prompt_tokens_details = other.prompt_tokens_details
+        elif other.prompt_tokens_details is None:
+            total_prompt_tokens_details = self.prompt_tokens_details
+        else:
+            total_prompt_tokens_details = self.prompt_tokens_details + other.prompt_tokens_details
+
+        if self.completion_tokens_details is None and other.completion_tokens_details is None:
+            total_completion_tokens_details = None
+        elif self.completion_tokens_details is None:
+            total_completion_tokens_details = other.completion_tokens_details
+        elif other.completion_tokens_details is None:
+            total_completion_tokens_details = self.completion_tokens_details
+        else:
+            total_completion_tokens_details = self.completion_tokens_details + other.completion_tokens_details
+
         return UsageStatistics(
             completion_tokens=self.completion_tokens + other.completion_tokens,
             prompt_tokens=self.prompt_tokens + other.prompt_tokens,
             total_tokens=self.total_tokens + other.total_tokens,
+            prompt_tokens_details=total_prompt_tokens_details,
+            completion_tokens_details=total_completion_tokens_details,
         )
 
 
@@ -70,7 +119,7 @@ class ChatCompletionResponse(BaseModel):
 
     id: str
     choices: List[Choice]
-    created: datetime.datetime
+    created: Union[datetime.datetime, int]
     model: Optional[str] = None  # NOTE: this is not consistent with OpenAI API standard, however is necessary to support local LLMs
     # system_fingerprint: str  # docs say this is mandatory, but in reality API returns None
     system_fingerprint: Optional[str] = None
@@ -138,7 +187,7 @@ class ChatCompletionChunkResponse(BaseModel):
 
     id: str
     choices: List[ChunkChoice]
-    created: Union[datetime.datetime, str]
+    created: Union[datetime.datetime, int]
     model: str
     # system_fingerprint: str  # docs say this is mandatory, but in reality API returns None
     system_fingerprint: Optional[str] = None

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/server/rest_api/chat_completions_interface.py

@@ -238,7 +238,7 @@ class ChatCompletionsStreamingInterface(AgentChunkStreamingInterface):
                     return ChatCompletionChunk(
                         id=chunk.id,
                         object=chunk.object,
-                        created=chunk.created.timestamp(),
+                        created=chunk.created,
                         model=chunk.model,
                         choices=[
                             Choice(
@@ -256,7 +256,7 @@ class ChatCompletionsStreamingInterface(AgentChunkStreamingInterface):
                 return ChatCompletionChunk(
                     id=chunk.id,
                     object=chunk.object,
-                    created=chunk.created.timestamp(),
+                    created=chunk.created,
                     model=chunk.model,
                     choices=[
                         Choice(

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/server/rest_api/interface.py

@@ -1001,7 +1001,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 # Example case that would trigger here:
                 # id='chatcmpl-AKtUvREgRRvgTW6n8ZafiKuV0mxhQ'
                 # choices=[ChunkChoice(finish_reason=None, index=0, delta=MessageDelta(content=None, tool_calls=None, function_call=None), logprobs=None)]
-                # created=datetime.datetime(2024, 10, 21, 20, 40, 57, tzinfo=TzInfo(UTC))
+                # created=1713216662
                 # model='gpt-4o-mini-2024-07-18'
                 # object='chat.completion.chunk'
                 warnings.warn(f"Couldn't find delta in chunk: {chunk}")

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/server/rest_api/routers/v1/messages.py

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header
+from fastapi import APIRouter, Body, Depends, Header, status
 from fastapi.exceptions import HTTPException
 from starlette.requests import Request
 
@@ -11,6 +11,7 @@ from letta.schemas.job import BatchJob, JobStatus, JobType, JobUpdate
 from letta.schemas.letta_request import CreateBatch
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.settings import settings
 
 router = APIRouter(prefix="/messages", tags=["messages"])
 
@@ -43,6 +44,13 @@ async def create_messages_batch(
         if length > max_bytes:
             raise HTTPException(status_code=413, detail=f"Request too large ({length} bytes). Max is {max_bytes} bytes.")
 
+    # Reject request if env var is not set
+    if not settings.enable_batch_job_polling:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Server misconfiguration: LETTA_ENABLE_BATCH_JOB_POLLING is set to False.",
+        )
+
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     batch_job = BatchJob(
         user_id=actor.id,

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/letta/services/agent_manager.py

@@ -161,7 +161,7 @@ class AgentManager:
     # Basic CRUD operations
     # ======================================================================================================================
     @trace_method
-    def create_agent(self, agent_create: CreateAgent, actor: PydanticUser) -> PydanticAgentState:
+    def create_agent(self, agent_create: CreateAgent, actor: PydanticUser, _test_only_force_id: Optional[str] = None) -> PydanticAgentState:
         # validate required configs
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
@@ -239,6 +239,10 @@ class AgentManager:
                     created_by_id=actor.id,
                     last_updated_by_id=actor.id,
                 )
+
+                if _test_only_force_id:
+                    new_agent.id = _test_only_force_id
+
                 session.add(new_agent)
                 session.flush()
                 aid = new_agent.id

{letta_nightly-0.7.1.dev20250423104245 → letta_nightly-0.7.2.dev20250423222439}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.7.1.dev20250423104245"
+version = "0.7.2.dev20250423222439"
 packages = [
     {include = "letta"},
 ]