letta-nightly 0.11.6.dev20250903104037__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

letta/server/rest_api/utils.py

@@ -7,8 +7,7 @@ from typing import TYPE_CHECKING, AsyncGenerator, Dict, Iterable, List, Optional
 
 from fastapi import Header, HTTPException
 from openai.types.chat import ChatCompletionMessageParam
-from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall, Function as OpenAIFunction
 from openai.types.chat.completion_create_params import CompletionCreateParams
 from pydantic import BaseModel
 
@@ -26,10 +25,11 @@ from letta.log import get_logger
 from letta.otel.context import get_ctx_attributes
 from letta.otel.metric_registry import MetricRegistry
 from letta.otel.tracing import tracer
+from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.message import Message, MessageCreate, ToolReturn
+from letta.schemas.message import ApprovalCreate, Message, MessageCreate, ToolReturn
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -177,25 +177,31 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ti
     return messages
 
 
-def create_letta_messages_from_llm_response(
+def create_approval_response_message_from_input(agent_state: AgentState, input_message: ApprovalCreate) -> List[Message]:
+    return [
+        Message(
+            role=MessageRole.approval,
+            agent_id=agent_state.id,
+            model=agent_state.llm_config.model,
+            approval_request_id=input_message.approval_request_id,
+            approve=input_message.approve,
+            denial_reason=input_message.reason,
+        )
+    ]
+
+
+def create_approval_request_message_from_llm_response(
     agent_id: str,
     model: str,
     function_name: str,
     function_arguments: Dict,
-    tool_execution_result: ToolExecutionResult,
     tool_call_id: str,
-    function_call_success: bool,
-    function_response: Optional[str],
-    timezone: str,
     actor: User,
     continue_stepping: bool = False,
-    heartbeat_reason: Optional[str] = None,
     reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
-    llm_batch_item_id: Optional[str] = None,
     step_id: str | None = None,
-) -> List[Message]:
-    messages = []
+) -> Message:
     # Construct the tool call with the assistant's message
     # Force set request_heartbeat in tool_args to calculated continue_stepping
     function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
@@ -209,19 +215,68 @@ def create_letta_messages_from_llm_response(
     )
     # TODO: Use ToolCallContent instead of tool_calls
     # TODO: This helps preserve ordering
-    assistant_message = Message(
-        role=MessageRole.assistant,
+    approval_message = Message(
+        role=MessageRole.approval,
         content=reasoning_content if reasoning_content else [],
         agent_id=agent_id,
         model=model,
         tool_calls=[tool_call],
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
-        batch_item_id=llm_batch_item_id,
+        step_id=step_id,
     )
     if pre_computed_assistant_message_id:
-        assistant_message.id = pre_computed_assistant_message_id
-    messages.append(assistant_message)
+        approval_message.id = pre_computed_assistant_message_id
+    return approval_message
+
+
+def create_letta_messages_from_llm_response(
+    agent_id: str,
+    model: str,
+    function_name: str,
+    function_arguments: Dict,
+    tool_execution_result: ToolExecutionResult,
+    tool_call_id: str,
+    function_call_success: bool,
+    function_response: Optional[str],
+    timezone: str,
+    actor: User,
+    continue_stepping: bool = False,
+    heartbeat_reason: Optional[str] = None,
+    reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
+    pre_computed_assistant_message_id: Optional[str] = None,
+    llm_batch_item_id: Optional[str] = None,
+    step_id: str | None = None,
+    is_approval_response: bool | None = None,
+) -> List[Message]:
+    messages = []
+    if not is_approval_response:
+        # Construct the tool call with the assistant's message
+        # Force set request_heartbeat in tool_args to calculated continue_stepping
+        function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
+        tool_call = OpenAIToolCall(
+            id=tool_call_id,
+            function=OpenAIFunction(
+                name=function_name,
+                arguments=json.dumps(function_arguments),
+            ),
+            type="function",
+        )
+        # TODO: Use ToolCallContent instead of tool_calls
+        # TODO: This helps preserve ordering
+        assistant_message = Message(
+            role=MessageRole.assistant,
+            content=reasoning_content if reasoning_content else [],
+            agent_id=agent_id,
+            model=model,
+            tool_calls=[tool_call],
+            tool_call_id=tool_call_id,
+            created_at=get_utc_time(),
+            batch_item_id=llm_batch_item_id,
+        )
+        if pre_computed_assistant_message_id:
+            assistant_message.id = pre_computed_assistant_message_id
+        messages.append(assistant_message)
 
     # TODO: Use ToolReturnContent instead of TextContent
     # TODO: This helps preserve ordering
@@ -394,7 +449,9 @@ def convert_in_context_letta_messages_to_openai(in_context_messages: List[Messag
                     pass  # It's not JSON, leave as-is
 
         # Finally, convert to dict using your existing method
-        openai_messages.append(msg.to_openai_dict())
+        m = msg.to_openai_dict()
+        assert m is not None
+        openai_messages.append(m)
 
     return openai_messages
 

letta/server/server.py

@@ -30,8 +30,10 @@ from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
 
 # TODO use custom interface
-from letta.interface import AgentInterface  # abstract
-from letta.interface import CLIInterface  # for printing to terminal
+from letta.interface import (
+    AgentInterface,  # abstract
+    CLIInterface,  # for printing to terminal
+)
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.otel.tracing import log_event, trace_method
@@ -52,7 +54,7 @@ from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
-from letta.schemas.passage import Passage, PassageUpdate
+from letta.schemas.passage import Passage
 from letta.schemas.pip_requirement import PipRequirement
 from letta.schemas.providers import (
     AnthropicProvider,
@@ -1114,7 +1116,7 @@ class SyncServer(Server):
         ascending: Optional[bool] = True,
     ) -> List[Passage]:
         # iterate over records
-        records = await self.agent_manager.list_agent_passages_async(
+        records = await self.agent_manager.query_agent_passages_async(
             actor=actor,
             agent_id=agent_id,
             after=after,
@@ -1125,18 +1127,17 @@ class SyncServer(Server):
         )
         return records
 
-    async def insert_archival_memory_async(self, agent_id: str, memory_contents: str, actor: User) -> List[Passage]:
+    async def insert_archival_memory_async(
+        self, agent_id: str, memory_contents: str, actor: User, tags: Optional[List[str]], created_at: Optional[datetime]
+    ) -> List[Passage]:
         # Get the agent object (loaded in memory)
         agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
 
-        # Insert passages into the archive
-        passages = await self.passage_manager.insert_passage(agent_state=agent_state, text=memory_contents, actor=actor)
-
-        return passages
+        # Use passage manager which handles dual-write to Turbopuffer if enabled
+        passages = await self.passage_manager.insert_passage(
+            agent_state=agent_state, text=memory_contents, tags=tags, actor=actor, created_at=created_at
+        )
 
-    def modify_archival_memory(self, agent_id: str, memory_id: str, passage: PassageUpdate, actor: User) -> List[Passage]:
-        passage = Passage(**passage.model_dump(exclude_unset=True, exclude_none=True))
-        passages = self.passage_manager.update_passage_by_id(passage_id=memory_id, passage=passage, actor=actor)
         return passages
 
     async def delete_archival_memory_async(self, memory_id: str, actor: User):
@@ -1270,7 +1271,7 @@ class SyncServer(Server):
         await self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
-        passages_to_be_deleted = await self.agent_manager.list_passages_async(actor=actor, source_id=source_id, limit=None)
+        passages_to_be_deleted = await self.agent_manager.query_source_passages_async(actor=actor, source_id=source_id, limit=None)
         await self.passage_manager.delete_source_passages_async(actor=actor, passages=passages_to_be_deleted)
 
         # TODO: delete data from agent passage stores (?)
@@ -1316,27 +1317,6 @@ class SyncServer(Server):
     async def sleeptime_document_ingest_async(
         self, main_agent: AgentState, source: Source, actor: User, clear_history: bool = False
     ) -> None:
-        # TEMPORARILY DISABLE UNTIL V2
-        # sleeptime_agent_state = await self.create_document_sleeptime_agent_async(main_agent, source, actor, clear_history)
-        # sleeptime_agent = LettaAgent(
-        #     agent_id=sleeptime_agent_state.id,
-        #     message_manager=self.message_manager,
-        #     agent_manager=self.agent_manager,
-        #     block_manager=self.block_manager,
-        #     job_manager=self.job_manager,
-        #     passage_manager=self.passage_manager,
-        #     actor=actor,
-        #     step_manager=self.step_manager,
-        #     telemetry_manager=self.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-        # )
-        # passages = await self.agent_manager.list_passages_async(actor=actor, source_id=source.id)
-        # for passage in passages:
-        #     await sleeptime_agent.step(
-        #         input_messages=[
-        #             MessageCreate(role="user", content=passage.text),
-        #         ]
-        #     )
-        # await self.agent_manager.delete_agent_async(agent_id=sleeptime_agent_state.id, actor=actor)
         pass
 
     async def _remove_file_from_agent(self, agent_id: str, file_id: str, actor: User) -> None:
@@ -1556,7 +1536,16 @@ class SyncServer(Server):
         local_configs = self.get_local_llm_configs()
         llm_models.extend(local_configs)
 
-        return llm_models
+        # dedupe by handle for uniqueness
+        # Seems like this is required from the tests?
+        seen_handles = set()
+        unique_models = []
+        for model in llm_models:
+            if model.handle not in seen_handles:
+                seen_handles.add(model.handle)
+                unique_models.append(model)
+
+        return unique_models
 
     def list_embedding_models(self, actor: User) -> List[EmbeddingConfig]:
         """List available embedding models"""