letta-nightly 0.11.7.dev20251006104136__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/step_manager.py

@@ -8,7 +8,6 @@ from sqlalchemy.orm import Session
 
 from letta.helpers.singleton import singleton
 from letta.orm.errors import NoResultFound
-from letta.orm.job import Job as JobModel
 from letta.orm.message import Message as MessageModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
@@ -48,6 +47,7 @@ class StepManager:
         feedback: Optional[Literal["positive", "negative"]] = None,
         has_feedback: Optional[bool] = None,
         project_id: Optional[str] = None,
+        run_id: Optional[str] = None,
     ) -> List[PydanticStep]:
         """List all jobs with optional pagination and status filter."""
         async with db_registry.async_session() as session:
@@ -62,6 +62,8 @@ class StepManager:
                 filter_kwargs["feedback"] = feedback
             if project_id:
                 filter_kwargs["project_id"] = project_id
+            if run_id:
+                filter_kwargs["run_id"] = run_id
             steps = await StepModel.list_async(
                 db_session=session,
                 before=before,
@@ -88,7 +90,7 @@ class StepManager:
         context_window_limit: int,
         usage: UsageStatistics,
         provider_id: Optional[str] = None,
-        job_id: Optional[str] = None,
+        run_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
         stop_reason: Optional[LettaStopReason] = None,
@@ -109,7 +111,7 @@ class StepManager:
             "completion_tokens": usage.completion_tokens,
             "prompt_tokens": usage.prompt_tokens,
             "total_tokens": usage.total_tokens,
-            "job_id": job_id,
+            "run_id": run_id,
             "tags": [],
             "tid": None,
             "trace_id": get_trace_id(),  # Get the current trace ID
@@ -123,8 +125,8 @@ class StepManager:
         if stop_reason:
             step_data["stop_reason"] = stop_reason.stop_reason
         with db_registry.session() as session:
-            if job_id:
-                self._verify_job_access(session, job_id, actor, access=["write"])
+            if run_id:
+                self._verify_run_access(session, run_id, actor, access=["write"])
             new_step = StepModel(**step_data)
             new_step.create(session)
             return new_step.to_pydantic()
@@ -142,13 +144,14 @@ class StepManager:
         context_window_limit: int,
         usage: UsageStatistics,
         provider_id: Optional[str] = None,
-        job_id: Optional[str] = None,
+        run_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
         stop_reason: Optional[LettaStopReason] = None,
         status: Optional[StepStatus] = None,
         error_type: Optional[str] = None,
         error_data: Optional[Dict] = None,
+        allow_partial: Optional[bool] = False,
     ) -> PydanticStep:
         step_data = {
             "origin": None,
@@ -163,7 +166,7 @@ class StepManager:
             "completion_tokens": usage.completion_tokens,
             "prompt_tokens": usage.prompt_tokens,
             "total_tokens": usage.total_tokens,
-            "job_id": job_id,
+            "run_id": run_id,
             "tags": [],
             "tid": None,
             "trace_id": get_trace_id(),  # Get the current trace ID
@@ -176,7 +179,15 @@ class StepManager:
             step_data["id"] = step_id
         if stop_reason:
             step_data["stop_reason"] = stop_reason.stop_reason
+
         async with db_registry.async_session() as session:
+            if allow_partial:
+                try:
+                    new_step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
+                    return new_step.to_pydantic()
+                except NoResultFound:
+                    pass
+
             new_step = StepModel(**step_data)
             await new_step.create_async(session, no_commit=True, no_refresh=True)
             pydantic_step = new_step.to_pydantic()
@@ -420,10 +431,11 @@ class StepManager:
         tool_execution_ns: Optional[int] = None,
         step_ns: Optional[int] = None,
         agent_id: Optional[str] = None,
-        job_id: Optional[str] = None,
+        run_id: Optional[str] = None,
         project_id: Optional[str] = None,
         template_id: Optional[str] = None,
         base_template_id: Optional[str] = None,
+        allow_partial: Optional[bool] = False,
     ) -> PydanticStepMetrics:
         """Record performance metrics for a step.
 
@@ -434,7 +446,7 @@ class StepManager:
             tool_execution_ns: Time spent on tool execution in nanoseconds
             step_ns: Total time for the step in nanoseconds
             agent_id: The ID of the agent
-            job_id: The ID of the job
+            run_id: The ID of the run
             project_id: The ID of the project
             template_id: The ID of the template
             base_template_id: The ID of the base template
@@ -452,11 +464,18 @@ class StepManager:
             if step.organization_id != actor.organization_id:
                 raise Exception("Unauthorized")
 
+            if allow_partial:
+                try:
+                    metrics = await StepMetricsModel.read_async(db_session=session, identifier=step_id, actor=actor)
+                    return metrics.to_pydantic()
+                except NoResultFound:
+                    pass
+
             metrics_data = {
                 "id": step_id,
                 "organization_id": actor.organization_id,
                 "agent_id": agent_id or step.agent_id,
-                "job_id": job_id or step.job_id,
+                "run_id": run_id,
                 "project_id": project_id or step.project_id,
                 "llm_request_ns": llm_request_ns,
                 "tool_execution_ns": tool_execution_ns,
@@ -469,62 +488,66 @@ class StepManager:
             await metrics.create_async(session)
             return metrics.to_pydantic()
 
-    def _verify_job_access(
+    def _verify_run_access(
         self,
         session: Session,
-        job_id: str,
+        run_id: str,
         actor: PydanticUser,
         access: List[Literal["read", "write", "delete"]] = ["read"],
-    ) -> JobModel:
+    ):
         """
-        Verify that a job exists and the user has the required access.
+        Verify that a run exists and the user has the required access.
 
         Args:
             session: The database session
-            job_id: The ID of the job to verify
+            run_id: The ID of the run to verify
             actor: The user making the request
 
         Returns:
-            The job if it exists and the user has access
+            The run if it exists and the user has access
 
         Raises:
-            NoResultFound: If the job does not exist or user does not have access
+            NoResultFound: If the run does not exist or user does not have access
         """
-        job_query = select(JobModel).where(JobModel.id == job_id)
-        job_query = JobModel.apply_access_predicate(job_query, actor, access, AccessType.USER)
-        job = session.execute(job_query).scalar_one_or_none()
-        if not job:
-            raise NoResultFound(f"Job with id {job_id} does not exist or user does not have access")
-        return job
+        from letta.orm.run import Run as RunModel
+
+        run_query = select(RunModel).where(RunModel.id == run_id)
+        run_query = RunModel.apply_access_predicate(run_query, actor, access, AccessType.USER)
+        run = session.execute(run_query).scalar_one_or_none()
+        if not run:
+            raise NoResultFound(f"Run with id {run_id} does not exist or user does not have access")
+        return run
 
     @staticmethod
-    async def _verify_job_access_async(
+    async def _verify_run_access_async(
         session: AsyncSession,
-        job_id: str,
+        run_id: str,
         actor: PydanticUser,
         access: List[Literal["read", "write", "delete"]] = ["read"],
-    ) -> JobModel:
+    ):
         """
-        Verify that a job exists and the user has the required access asynchronously.
+        Verify that a run exists and the user has the required access asynchronously.
 
         Args:
             session: The async database session
-            job_id: The ID of the job to verify
+            run_id: The ID of the run to verify
             actor: The user making the request
 
         Returns:
-            The job if it exists and the user has access
+            The run if it exists and the user has access
 
         Raises:
-            NoResultFound: If the job does not exist or user does not have access
+            NoResultFound: If the run does not exist or user does not have access
         """
-        job_query = select(JobModel).where(JobModel.id == job_id)
-        job_query = JobModel.apply_access_predicate(job_query, actor, access, AccessType.USER)
-        result = await session.execute(job_query)
-        job = result.scalar_one_or_none()
-        if not job:
-            raise NoResultFound(f"Job with id {job_id} does not exist or user does not have access")
-        return job
+        from letta.orm.run import Run as RunModel
+
+        run_query = select(RunModel).where(RunModel.id == run_id)
+        run_query = RunModel.apply_access_predicate(run_query, actor, access, AccessType.USER)
+        result = await session.execute(run_query)
+        run = result.scalar_one_or_none()
+        if not run:
+            raise NoResultFound(f"Run with id {run_id} does not exist or user does not have access")
+        return run
 
 
 # noinspection PyTypeChecker
@@ -549,7 +572,7 @@ class NoopStepManager(StepManager):
         context_window_limit: int,
         usage: UsageStatistics,
         provider_id: Optional[str] = None,
-        job_id: Optional[str] = None,
+        run_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
         stop_reason: Optional[LettaStopReason] = None,
@@ -572,7 +595,7 @@ class NoopStepManager(StepManager):
         context_window_limit: int,
         usage: UsageStatistics,
         provider_id: Optional[str] = None,
-        job_id: Optional[str] = None,
+        run_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
         stop_reason: Optional[LettaStopReason] = None,

letta/services/summarizer/summarizer.py

@@ -10,7 +10,7 @@ from letta.llm_api.llm_client import LLMClient
 from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.prompts import gpt_summarize
-from letta.schemas.enums import MessageRole
+from letta.schemas.enums import AgentType, MessageRole
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreate
@@ -189,6 +189,7 @@ class Summarizer:
             # We already packed, don't pack again
             wrap_user_message=False,
             wrap_system_message=False,
+            run_id=None,  # TODO: add this
         )[0]
 
         # Create the message in the DB
@@ -383,17 +384,18 @@ async def simple_summary(messages: List[Message], llm_config: LLMConfig, actor:
             {"role": "user", "content": summary_transcript},
         ]
     input_messages_obj = [simple_message_wrapper(msg) for msg in input_messages]
-    request_data = llm_client.build_request_data(input_messages_obj, llm_config, tools=[])
+    # Build a local LLMConfig for v1-style summarization which uses native content and must not
+    # include inner thoughts in kwargs to avoid conflicts in Anthropic formatting
+    summarizer_llm_config = LLMConfig(**llm_config.model_dump())
+    summarizer_llm_config.put_inner_thoughts_in_kwargs = False
 
-    # NOTE: we should disable the inner_thoughts_in_kwargs here, because we don't use it
-    # I'm leaving it commented it out for now for safety but is fine assuming the var here is a copy not a reference
-    # llm_config.put_inner_thoughts_in_kwargs = False
+    request_data = llm_client.build_request_data(AgentType.letta_v1_agent, input_messages_obj, summarizer_llm_config, tools=[])
     try:
-        response_data = await llm_client.request_async(request_data, llm_config)
+        response_data = await llm_client.request_async(request_data, summarizer_llm_config)
     except Exception as e:
         # handle LLM error (likely a context window exceeded error)
         raise llm_client.handle_llm_error(e)
-    response = llm_client.convert_response_to_chat_completion(response_data, input_messages_obj, llm_config)
+    response = llm_client.convert_response_to_chat_completion(response_data, input_messages_obj, summarizer_llm_config)
     if response.choices[0].message.content is None:
         logger.warning("No content returned from summarizer")
         # TODO raise an error error instead?

letta/services/telemetry_manager.py

@@ -39,22 +39,6 @@ class TelemetryManager:
             await session.commit()
             return pydantic_provider_trace
 
-    @enforce_types
-    @trace_method
-    def create_provider_trace(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
-        with db_registry.session() as session:
-            provider_trace = ProviderTraceModel(**provider_trace_create.model_dump())
-            provider_trace.organization_id = actor.organization_id
-            if provider_trace_create.request_json:
-                request_json_str = json_dumps(provider_trace_create.request_json)
-                provider_trace.request_json = json_loads(request_json_str)
-
-            if provider_trace_create.response_json:
-                response_json_str = json_dumps(provider_trace_create.response_json)
-                provider_trace.response_json = json_loads(response_json_str)
-            provider_trace.create(session, actor=actor)
-            return provider_trace.to_pydantic()
-
 
 @singleton
 class NoopTelemetryManager(TelemetryManager):

letta/services/tool_executor/builtin_tool_executor.py

@@ -209,6 +209,41 @@ class LettaBuiltinToolExecutor(ToolExecutor):
         from readability import Document
         from trafilatura import extract, fetch_url
 
+        # Try exa first
+        try:
+            from exa_py import Exa
+
+            agent_state_tool_env_vars = agent_state.get_agent_env_vars_as_dict()
+            exa_api_key = agent_state_tool_env_vars.get("EXA_API_KEY") or tool_settings.exa_api_key
+            if exa_api_key:
+                logger.info(f"[DEBUG] Starting Exa fetch content for url: '{url}'")
+                exa = Exa(api_key=exa_api_key)
+
+                results = await asyncio.to_thread(
+                    lambda: exa.get_contents(
+                        [url],
+                        text=True,
+                    ).results
+                )
+
+                if len(results) > 0:
+                    result = results[0]
+                    return json.dumps(
+                        {
+                            "title": result.title,
+                            "published_date": result.published_date,
+                            "author": result.author,
+                            "text": result.text,
+                        }
+                    )
+                else:
+                    logger.info(f"[DEBUG] Exa did not return content for '{url}', falling back to local fetch.")
+            else:
+                logger.info("[DEBUG] No Exa key available, falling back to local fetch.")
+        except ImportError:
+            logger.info("[DEBUG] Exa pip package unavailable, falling back to local fetch.")
+            pass
+
         try:
             # single thread pool call for the entire trafilatura pipeline
             def trafilatura_pipeline():