letta-nightly 0.11.7.dev20251008104128__py3-none-any.whl → 0.12.0.dev20251009203644__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -562,14 +562,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                 if prev_message_type and prev_message_type != "tool_call_message":
                     message_index += 1
+                tool_call_delta = ToolCallDelta(
+                    name=json_reasoning_content.get("name"),
+                    arguments=json.dumps(json_reasoning_content.get("arguments")),
+                    tool_call_id=None,
+                )
                 processed_chunk = ToolCallMessage(
                     id=message_id,
                     date=message_date,
-                    tool_call=ToolCallDelta(
-                        name=json_reasoning_content.get("name"),
-                        arguments=json.dumps(json_reasoning_content.get("arguments")),
-                        tool_call_id=None,
-                    ),
+                    tool_call=tool_call_delta,
+                    tool_calls=tool_call_delta,
                     name=name,
                     otid=Message.generate_otid_from_id(message_id, message_index),
                 )
@@ -703,14 +705,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     else:
                         if prev_message_type and prev_message_type != "tool_call_message":
                             message_index += 1
+                        tc_delta = ToolCallDelta(
+                            name=tool_call_delta.get("name"),
+                            arguments=tool_call_delta.get("arguments"),
+                            tool_call_id=tool_call_delta.get("id"),
+                        )
                         processed_chunk = ToolCallMessage(
                             id=message_id,
                             date=message_date,
-                            tool_call=ToolCallDelta(
-                                name=tool_call_delta.get("name"),
-                                arguments=tool_call_delta.get("arguments"),
-                                tool_call_id=tool_call_delta.get("id"),
-                            ),
+                            tool_call=tc_delta,
+                            tool_calls=tc_delta,
                             name=name,
                             otid=Message.generate_otid_from_id(message_id, message_index),
                         )
@@ -779,14 +783,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             else:
                                 if prev_message_type and prev_message_type != "tool_call_message":
                                     message_index += 1
+                                tc_delta = ToolCallDelta(
+                                    name=self.function_name_buffer,
+                                    arguments=None,
+                                    tool_call_id=self.function_id_buffer,
+                                )
                                 processed_chunk = ToolCallMessage(
                                     id=message_id,
                                     date=message_date,
-                                    tool_call=ToolCallDelta(
-                                        name=self.function_name_buffer,
-                                        arguments=None,
-                                        tool_call_id=self.function_id_buffer,
-                                    ),
+                                    tool_call=tc_delta,
+                                    tool_calls=tc_delta,
                                     name=name,
                                     otid=Message.generate_otid_from_id(message_id, message_index),
                                 )
@@ -843,14 +849,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     combined_chunk = self.function_args_buffer + updates_main_json
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
+                                    tc_delta = ToolCallDelta(
+                                        name=None,
+                                        arguments=combined_chunk,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
-                                        tool_call=ToolCallDelta(
-                                            name=None,
-                                            arguments=combined_chunk,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tc_delta,
+                                        tool_calls=tc_delta,
                                         name=name,
                                         otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
@@ -861,14 +869,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     # If there's no buffer to clear, just output a new chunk with new data
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
+                                    tc_delta = ToolCallDelta(
+                                        name=None,
+                                        arguments=updates_main_json,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
-                                        tool_call=ToolCallDelta(
-                                            name=None,
-                                            arguments=updates_main_json,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tc_delta,
+                                        tool_calls=tc_delta,
                                         name=name,
                                         otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
@@ -992,14 +1002,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tc_delta = ToolCallDelta(
+                        name=tool_call_delta.get("name"),
+                        arguments=tool_call_delta.get("arguments"),
+                        tool_call_id=tool_call_delta.get("id"),
+                    )
                     processed_chunk = ToolCallMessage(
                         id=message_id,
                         date=message_date,
-                        tool_call=ToolCallDelta(
-                            name=tool_call_delta.get("name"),
-                            arguments=tool_call_delta.get("arguments"),
-                            tool_call_id=tool_call_delta.get("id"),
-                        ),
+                        tool_call=tc_delta,
+                        tool_calls=tc_delta,
                         name=name,
                         otid=Message.generate_otid_from_id(message_id, message_index),
                     )
@@ -1262,14 +1274,16 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # Store the ID of the tool call so allow skipping the corresponding response
                         self.prev_assistant_message_id = function_call.id
                     else:
+                        tool_call_obj = ToolCall(
+                            name=function_call.function.name,
+                            arguments=function_call.function.arguments,
+                            tool_call_id=function_call.id,
+                        )
                         processed_chunk = ToolCallMessage(
                             id=msg_obj.id,
                             date=msg_obj.created_at,
-                            tool_call=ToolCall(
-                                name=function_call.function.name,
-                                arguments=function_call.function.arguments,
-                                tool_call_id=function_call.id,
-                            ),
+                            tool_call=tool_call_obj,
+                            tool_calls=tool_call_obj,
                             name=msg_obj.name,
                             otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                         )
@@ -1303,14 +1317,29 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 # Skip this tool call receipt
                 return
             else:
+                from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+                status = msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success"
+                stdout = msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else []
+                stderr = msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else []
+
+                tool_return_obj = ToolReturnSchema(
+                    tool_return=msg,
+                    status=status,
+                    tool_call_id=msg_obj.tool_call_id,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
+
                 new_message = ToolReturnMessage(
                     id=msg_obj.id,
                     date=msg_obj.created_at,
                     tool_return=msg,
-                    status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success",
+                    status=status,
                     tool_call_id=msg_obj.tool_call_id,
-                    stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
-                    stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
+                    stdout=stdout,
+                    stderr=stderr,
+                    tool_returns=[tool_return_obj],
                     name=msg_obj.name,
                     otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                 )
@@ -1319,14 +1348,29 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             msg = msg.replace("Error: ", "", 1)
             # new_message = {"function_return": msg, "status": "error"}
             assert msg_obj.tool_call_id is not None
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            status = msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error"
+            stdout = msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else []
+            stderr = msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else []
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=msg,
+                status=status,
+                tool_call_id=msg_obj.tool_call_id,
+                stdout=stdout,
+                stderr=stderr,
+            )
+
             new_message = ToolReturnMessage(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
                 tool_return=msg,
-                status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error",
+                status=status,
                 tool_call_id=msg_obj.tool_call_id,
-                stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else [],
-                stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else [],
+                stdout=stdout,
+                stderr=stderr,
+                tool_returns=[tool_return_obj],
                 name=msg_obj.name,
                 otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
             )

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

@@ -120,6 +120,40 @@ async def check_provider(
         raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
 
 
+@router.post("/{provider_id}/check", response_model=None, operation_id="check_existing_provider")
+async def check_existing_provider(
+    provider_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Verify the API key and additional parameters for an existing provider.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        provider = await server.provider_manager.get_provider_async(provider_id=provider_id, actor=actor)
+
+        # Create a ProviderCheck from the existing provider
+        provider_check = ProviderCheck(
+            provider_type=provider.provider_type,
+            api_key=provider.api_key,
+            base_url=provider.base_url,
+        )
+
+        await server.provider_manager.check_provider_api_key(provider_check=provider_check)
+        return JSONResponse(
+            status_code=status.HTTP_200_OK, content={"message": f"Valid api key for provider_type={provider.provider_type.value}"}
+        )
+    except LLMAuthenticationError as e:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=f"{e.message}")
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Provider provider_id={provider_id} not found for user_id={actor.id}.")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"{e}")
+
+
 @router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
 async def delete_provider(
     provider_id: str,

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

@@ -13,6 +13,7 @@ from letta.schemas.letta_request import RetrieveStreamRequest
 from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
+from letta.schemas.run_metrics import RunMetrics
 from letta.schemas.step import Step
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.rest_api.redis_stream_manager import redis_sse_stream_generator
@@ -224,6 +225,23 @@ async def retrieve_run_usage(
         raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
 
 
+@router.get("/{run_id}/metrics", response_model=RunMetrics, operation_id="retrieve_metrics_for_run")
+async def retrieve_metrics_for_run(
+    run_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get run metrics by run ID.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        runs_manager = RunManager()
+        return await runs_manager.get_run_metrics_async(run_id=run_id, actor=actor)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Run metrics not found")
+
+
 @router.get(
     "/{run_id}/steps",
     response_model=List[Step],
@@ -247,18 +265,14 @@ async def list_run_steps(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
 
-    try:
-        steps = await runs_manager.get_run_steps(
-            run_id=run_id,
-            actor=actor,
-            limit=limit,
-            before=before,
-            after=after,
-            ascending=(order == "asc"),
-        )
-        return steps
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
+    return await runs_manager.get_run_steps(
+        run_id=run_id,
+        actor=actor,
+        limit=limit,
+        before=before,
+        after=after,
+        ascending=(order == "asc"),
+    )
 
 
 @router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
@@ -272,12 +286,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-
-    try:
-        run = await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
-        return run
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run not found")
+    return await runs_manager.delete_run(run_id=run_id, actor=actor)
 
 
 @router.post(

letta/server/server.py

@@ -1239,6 +1239,16 @@ class SyncServer(object):
                 function_args=tool_args,
                 tool=tool,
             )
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=str(tool_execution_result.func_return),
+                status=tool_execution_result.status,
+                tool_call_id="null",
+                stdout=tool_execution_result.stdout,
+                stderr=tool_execution_result.stderr,
+            )
+
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
@@ -1247,10 +1257,21 @@ class SyncServer(object):
                 tool_return=str(tool_execution_result.func_return),
                 stdout=tool_execution_result.stdout,
                 stderr=tool_execution_result.stderr,
+                tool_returns=[tool_return_obj],
             )
 
         except Exception as e:
             func_return = get_friendly_error_msg(function_name=tool.name, exception_name=type(e).__name__, exception_message=str(e))
+            from letta.schemas.letta_message import ToolReturn as ToolReturnSchema
+
+            tool_return_obj = ToolReturnSchema(
+                tool_return=func_return,
+                status="error",
+                tool_call_id="null",
+                stdout=[],
+                stderr=[traceback.format_exc()],
+            )
+
             return ToolReturnMessage(
                 id="null",
                 tool_call_id="null",
@@ -1259,6 +1280,7 @@ class SyncServer(object):
                 tool_return=func_return,
                 stdout=[],
                 stderr=[traceback.format_exc()],
+                tool_returns=[tool_return_obj],
             )
 
     # MCP wrappers

letta/services/context_window_calculator/token_counter.py

@@ -74,7 +74,7 @@ class AnthropicTokenCounter(TokenCounter):
         return await self.client.count_tokens(model=self.model, tools=tools)
 
     def convert_messages(self, messages: List[Any]) -> List[Dict[str, Any]]:
-        return Message.to_anthropic_dicts_from_list(messages)
+        return Message.to_anthropic_dicts_from_list(messages, current_model=self.model)
 
 
 class TiktokenCounter(TokenCounter):

letta/services/helpers/run_manager_helper.py

@@ -2,14 +2,10 @@ from datetime import datetime
 from typing import Optional
 
 from sqlalchemy import asc, desc, nulls_last, select
-from letta.settings import DatabaseChoice, settings
 
 from letta.orm.run import Run as RunModel
-from letta.settings import DatabaseChoice, settings
-from sqlalchemy import asc, desc
-from typing import Optional
-
 from letta.services.helpers.agent_manager_helper import _cursor_filter
+from letta.settings import DatabaseChoice, settings
 
 
 async def _apply_pagination_async(
@@ -29,17 +25,11 @@ async def _apply_pagination_async(
         sort_nulls_last = False
 
     if after:
-        result = (
-            await session.execute(
-                select(sort_column, RunModel.id).where(RunModel.id == after)
-            )
-        ).first()
+        result = (await session.execute(select(sort_column, RunModel.id).where(RunModel.id == after))).first()
         if result:
             after_sort_value, after_id = result
             # SQLite does not support as granular timestamping, so we need to round the timestamp
-            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
-                after_sort_value, datetime
-            ):
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(after_sort_value, datetime):
                 after_sort_value = after_sort_value.strftime("%Y-%m-%d %H:%M:%S")
             query = query.where(
                 _cursor_filter(
@@ -53,17 +43,11 @@ async def _apply_pagination_async(
             )
 
     if before:
-        result = (
-            await session.execute(
-                select(sort_column, RunModel.id).where(RunModel.id == before)
-            )
-        ).first()
+        result = (await session.execute(select(sort_column, RunModel.id).where(RunModel.id == before))).first()
         if result:
             before_sort_value, before_id = result
             # SQLite does not support as granular timestamping, so we need to round the timestamp
-            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
-                before_sort_value, datetime
-            ):
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(before_sort_value, datetime):
                 before_sort_value = before_sort_value.strftime("%Y-%m-%d %H:%M:%S")
             query = query.where(
                 _cursor_filter(

letta/services/run_manager.py

@@ -8,9 +8,11 @@ from sqlalchemy.orm import Session
 
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
+from letta.orm.agent import Agent as AgentModel
 from letta.orm.errors import NoResultFound
 from letta.orm.message import Message as MessageModel
 from letta.orm.run import Run as RunModel
+from letta.orm.run_metrics import RunMetrics as RunMetricsModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
 from letta.otel.tracing import log_event, trace_method
@@ -21,6 +23,7 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.run import Run as PydanticRun, RunUpdate
+from letta.schemas.run_metrics import RunMetrics as PydanticRunMetrics
 from letta.schemas.step import Step as PydanticStep
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User as PydanticUser
@@ -62,6 +65,23 @@ class RunManager:
             run = RunModel(**run_data)
             run.organization_id = organization_id
             run = await run.create_async(session, actor=actor, no_commit=True, no_refresh=True)
+
+            # Create run metrics with start timestamp
+            import time
+
+            # Get the project_id from the agent
+            agent = await session.get(AgentModel, agent_id)
+            project_id = agent.project_id if agent else None
+
+            metrics = RunMetricsModel(
+                id=run.id,
+                organization_id=organization_id,
+                agent_id=agent_id,
+                project_id=project_id,
+                run_start_ns=int(time.time() * 1e9),  # Current time in nanoseconds
+                num_steps=0,  # Initialize to 0
+            )
+            await metrics.create_async(session)
             await session.commit()
 
         return run.to_pydantic()
@@ -178,6 +198,21 @@ class RunManager:
             await run.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
             final_metadata = run.metadata_
             pydantic_run = run.to_pydantic()
+
+            await session.commit()
+
+        # update run metrics table
+        num_steps = len(await self.step_manager.list_steps_async(run_id=run_id, actor=actor))
+        async with db_registry.async_session() as session:
+            metrics = await RunMetricsModel.read_async(db_session=session, identifier=run_id, actor=actor)
+            # Calculate runtime if run is completing
+            if is_terminal_update and metrics.run_start_ns:
+                import time
+
+                current_ns = int(time.time() * 1e9)
+                metrics.run_ns = current_ns - metrics.run_start_ns
+            metrics.num_steps = num_steps
+            await metrics.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
             await session.commit()
 
         # Dispatch callback outside of database session if needed
@@ -299,3 +334,31 @@ class RunManager:
                 raise NoResultFound(f"Run with id {run_id} not found")
             pydantic_run = run.to_pydantic()
             return pydantic_run.request_config
+
+    @enforce_types
+    async def get_run_metrics_async(self, run_id: str, actor: PydanticUser) -> PydanticRunMetrics:
+        """Get metrics for a run."""
+        async with db_registry.async_session() as session:
+            metrics = await RunMetricsModel.read_async(db_session=session, identifier=run_id, actor=actor)
+            return metrics.to_pydantic()
+
+    @enforce_types
+    async def get_run_steps(
+        self,
+        run_id: str,
+        actor: PydanticUser,
+        limit: Optional[int] = 100,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        ascending: bool = False,
+    ) -> List[PydanticStep]:
+        """Get steps for a run."""
+        async with db_registry.async_session() as session:
+            run = await RunModel.read_async(db_session=session, identifier=run_id, actor=actor, access_type=AccessType.ORGANIZATION)
+            if not run:
+                raise NoResultFound(f"Run with id {run_id} not found")
+
+        steps = await self.step_manager.list_steps_async(
+            actor=actor, run_id=run_id, limit=limit, before=before, after=after, order="asc" if ascending else "desc"
+        )
+        return steps

letta/system.py

@@ -248,7 +248,11 @@ def unpack_message(packed_message: str) -> str:
         warnings.warn(f"Was unable to find 'message' field in packed message object: '{packed_message}'")
         return packed_message
     else:
-        message_type = message_json["type"]
+        try:
+            message_type = message_json["type"]
+        except:
+            return packed_message
+
         if message_type != "user_message":
             warnings.warn(f"Expected type to be 'user_message', but was '{message_type}', so not unpacking: '{packed_message}'")
             return packed_message

{letta_nightly-0.11.7.dev20251008104128.dist-info → letta_nightly-0.12.0.dev20251009203644.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.7.dev20251008104128
+Version: 0.12.0.dev20251009203644
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License