letta-nightly 0.7.30.dev20250603104343__py3-none-any.whl → 0.8.0.dev20250604201135__py3-none-any.whl

letta/services/sandbox_config_manager.py

@@ -192,6 +192,15 @@ class SandboxConfigManager:
             sandbox.hard_delete(db_session=session, actor=actor)
             return sandbox.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def delete_sandbox_config_async(self, sandbox_config_id: str, actor: PydanticUser) -> PydanticSandboxConfig:
+        """Delete a sandbox configuration by its ID."""
+        async with db_registry.async_session() as session:
+            sandbox = await SandboxConfigModel.read_async(db_session=session, identifier=sandbox_config_id, actor=actor)
+            await sandbox.hard_delete_async(db_session=session, actor=actor)
+            return sandbox.to_pydantic()
+
     @enforce_types
     @trace_method
     def list_sandbox_configs(
@@ -305,6 +314,34 @@ class SandboxConfigManager:
                 env_var.create(session, actor=actor)
             return env_var.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def create_sandbox_env_var_async(
+        self, env_var_create: SandboxEnvironmentVariableCreate, sandbox_config_id: str, actor: PydanticUser
+    ) -> PydanticEnvVar:
+        """Create a new sandbox environment variable."""
+        env_var = PydanticEnvVar(**env_var_create.model_dump(), sandbox_config_id=sandbox_config_id, organization_id=actor.organization_id)
+
+        db_env_var = await self.get_sandbox_env_var_by_key_and_sandbox_config_id_async(env_var.key, env_var.sandbox_config_id, actor=actor)
+        if db_env_var:
+            update_data = env_var.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = {key: value for key, value in update_data.items() if getattr(db_env_var, key) != value}
+            # If there are changes, update the environment variable
+            if update_data:
+                db_env_var = await self.update_sandbox_env_var_async(db_env_var.id, SandboxEnvironmentVariableUpdate(**update_data), actor)
+            else:
+                printd(
+                    f"`create_or_update_sandbox_env_var` was called with user_id={actor.id}, organization_id={actor.organization_id}, "
+                    f"key={env_var.key}, but found existing variable with nothing to update."
+                )
+
+            return db_env_var
+        else:
+            async with db_registry.async_session() as session:
+                env_var = SandboxEnvVarModel(**env_var.model_dump(to_orm=True, exclude_none=True))
+                await env_var.create_async(session, actor=actor)
+                return env_var.to_pydantic()
+
     @enforce_types
     @trace_method
     def update_sandbox_env_var(
@@ -327,6 +364,28 @@ class SandboxConfigManager:
                 )
             return env_var.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def update_sandbox_env_var_async(
+        self, env_var_id: str, env_var_update: SandboxEnvironmentVariableUpdate, actor: PydanticUser
+    ) -> PydanticEnvVar:
+        """Update an existing sandbox environment variable."""
+        async with db_registry.async_session() as session:
+            env_var = await SandboxEnvVarModel.read_async(db_session=session, identifier=env_var_id, actor=actor)
+            update_data = env_var_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
+            update_data = {key: value for key, value in update_data.items() if getattr(env_var, key) != value}
+
+            if update_data:
+                for key, value in update_data.items():
+                    setattr(env_var, key, value)
+                await env_var.update_async(db_session=session, actor=actor)
+            else:
+                printd(
+                    f"`update_sandbox_env_var` called with user_id={actor.id}, organization_id={actor.organization_id}, "
+                    f"key={env_var.key}, but nothing to update."
+                )
+            return env_var.to_pydantic()
+
     @enforce_types
     @trace_method
     def delete_sandbox_env_var(self, env_var_id: str, actor: PydanticUser) -> PydanticEnvVar:
@@ -336,6 +395,15 @@ class SandboxConfigManager:
             env_var.hard_delete(db_session=session, actor=actor)
             return env_var.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def delete_sandbox_env_var_async(self, env_var_id: str, actor: PydanticUser) -> PydanticEnvVar:
+        """Delete a sandbox environment variable by its ID."""
+        async with db_registry.async_session() as session:
+            env_var = await SandboxEnvVarModel.read_async(db_session=session, identifier=env_var_id, actor=actor)
+            await env_var.hard_delete_async(db_session=session, actor=actor)
+            return env_var.to_pydantic()
+
     @enforce_types
     @trace_method
     def list_sandbox_env_vars(
@@ -392,6 +460,22 @@ class SandboxConfigManager:
             )
             return [env_var.to_pydantic() for env_var in env_vars]
 
+    @enforce_types
+    @trace_method
+    async def list_sandbox_env_vars_by_key_async(
+        self, key: str, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50
+    ) -> List[PydanticEnvVar]:
+        """List all sandbox environment variables with optional pagination."""
+        async with db_registry.async_session() as session:
+            env_vars = await SandboxEnvVarModel.list_async(
+                db_session=session,
+                after=after,
+                limit=limit,
+                organization_id=actor.organization_id,
+                key=key,
+            )
+            return [env_var.to_pydantic() for env_var in env_vars]
+
     @enforce_types
     @trace_method
     def get_sandbox_env_vars_as_dict(
@@ -434,3 +518,24 @@ class SandboxConfigManager:
                 return None
             except NoResultFound:
                 return None
+
+    @enforce_types
+    @trace_method
+    async def get_sandbox_env_var_by_key_and_sandbox_config_id_async(
+        self, key: str, sandbox_config_id: str, actor: Optional[PydanticUser] = None
+    ) -> Optional[PydanticEnvVar]:
+        """Retrieve a sandbox environment variable by its key and sandbox_config_id."""
+        async with db_registry.async_session() as session:
+            try:
+                env_var = await SandboxEnvVarModel.list_async(
+                    db_session=session,
+                    key=key,
+                    sandbox_config_id=sandbox_config_id,
+                    organization_id=actor.organization_id,
+                    limit=1,
+                )
+                if env_var:
+                    return env_var[0].to_pydantic()
+                return None
+            except NoResultFound:
+                return None

letta/services/source_manager.py

@@ -31,7 +31,7 @@ class SourceManager:
                 source.organization_id = actor.organization_id
                 source = SourceModel(**source.model_dump(to_orm=True, exclude_none=True))
                 await source.create_async(session, actor=actor)
-            return source.to_pydantic()
+                return source.to_pydantic()
 
     @enforce_types
     @trace_method
@@ -48,7 +48,7 @@ class SourceManager:
             if update_data:
                 for key, value in update_data.items():
                     setattr(source, key, value)
-                source.update(db_session=session, actor=actor)
+                await source.update_async(db_session=session, actor=actor)
             else:
                 printd(
                     f"`update_source` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={source.name}, but found existing source with nothing to update."
@@ -83,7 +83,7 @@ class SourceManager:
 
     @enforce_types
     @trace_method
-    async def size(self, actor: PydanticUser) -> int:
+    async def size_async(self, actor: PydanticUser) -> int:
         """
         Get the total count of sources for the given user.
         """
@@ -152,7 +152,7 @@ class SourceManager:
                 file_metadata.organization_id = actor.organization_id
                 file_metadata = FileMetadataModel(**file_metadata.model_dump(to_orm=True, exclude_none=True))
                 await file_metadata.create_async(session, actor=actor)
-            return file_metadata.to_pydantic()
+                return file_metadata.to_pydantic()
 
     # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
     @enforce_types
@@ -173,7 +173,6 @@ class SourceManager:
     ) -> List[PydanticFileMetadata]:
         """List all files with optional pagination."""
         async with db_registry.async_session() as session:
-            files_all = await FileMetadataModel.list_async(db_session=session, organization_id=actor.organization_id, source_id=source_id)
             files = await FileMetadataModel.list_async(
                 db_session=session, after=after, limit=limit, organization_id=actor.organization_id, source_id=source_id
             )

letta/services/step_manager.py

@@ -22,7 +22,7 @@ class StepManager:
 
     @enforce_types
     @trace_method
-    def list_steps(
+    async def list_steps_async(
         self,
         actor: PydanticUser,
         before: Optional[str] = None,
@@ -33,16 +33,19 @@ class StepManager:
         order: Optional[str] = None,
         model: Optional[str] = None,
         agent_id: Optional[str] = None,
+        trace_ids: Optional[list[str]] = None,
     ) -> List[PydanticStep]:
         """List all jobs with optional pagination and status filter."""
-        with db_registry.session() as session:
+        async with db_registry.async_session() as session:
             filter_kwargs = {"organization_id": actor.organization_id}
             if model:
                 filter_kwargs["model"] = model
             if agent_id:
                 filter_kwargs["agent_id"] = agent_id
+            if trace_ids:
+                filter_kwargs["trace_id"] = trace_ids
 
-            steps = StepModel.list(
+            steps = await StepModel.list_async(
                 db_session=session,
                 before=before,
                 after=after,
@@ -142,9 +145,9 @@ class StepManager:
 
     @enforce_types
     @trace_method
-    def get_step(self, step_id: str, actor: PydanticUser) -> PydanticStep:
-        with db_registry.session() as session:
-            step = StepModel.read(db_session=session, identifier=step_id, actor=actor)
+    async def get_step_async(self, step_id: str, actor: PydanticUser) -> PydanticStep:
+        async with db_registry.async_session() as session:
+            step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
             return step.to_pydantic()
 
     @enforce_types

letta/services/summarizer/summarizer.py

@@ -1,14 +1,16 @@
 import asyncio
 import json
 import traceback
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Union
 
+from letta.agents.ephemeral_summary_agent import EphemeralSummaryAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
 from letta.services.summarizer.enums import SummarizationMode
+from letta.tracing import trace_method
 
 logger = get_logger(__name__)
 
@@ -23,7 +25,7 @@ class Summarizer:
     def __init__(
         self,
         mode: SummarizationMode,
-        summarizer_agent: Optional["VoiceSleeptimeAgent"] = None,
+        summarizer_agent: Optional[Union[EphemeralSummaryAgent, "VoiceSleeptimeAgent"]] = None,
         message_buffer_limit: int = 10,
         message_buffer_min: int = 3,
     ):
@@ -35,7 +37,10 @@ class Summarizer:
         self.summarizer_agent = summarizer_agent
         # TODO: Move this to config
 
-    def summarize(self, in_context_messages: List[Message], new_letta_messages: List[Message]) -> Tuple[List[Message], bool]:
+    @trace_method
+    def summarize(
+        self, in_context_messages: List[Message], new_letta_messages: List[Message], force: bool = False, clear: bool = False
+    ) -> Tuple[List[Message], bool]:
         """
         Summarizes or trims in_context_messages according to the chosen mode,
         and returns the updated messages plus any optional "summary message".
@@ -43,6 +48,7 @@ class Summarizer:
         Args:
             in_context_messages: The existing messages in the conversation's context.
             new_letta_messages: The newly added Letta messages (just appended).
+            force: Force summarize even if the criteria is not met
 
         Returns:
             (updated_messages, summary_message)
@@ -51,7 +57,7 @@ class Summarizer:
                              (could be appended to the conversation if desired)
         """
         if self.mode == SummarizationMode.STATIC_MESSAGE_BUFFER:
-            return self._static_buffer_summarization(in_context_messages, new_letta_messages)
+            return self._static_buffer_summarization(in_context_messages, new_letta_messages, force=force, clear=clear)
         else:
             # Fallback or future logic
             return in_context_messages, False
@@ -69,42 +75,48 @@ class Summarizer:
         return task
 
     def _static_buffer_summarization(
-        self, in_context_messages: List[Message], new_letta_messages: List[Message]
+        self, in_context_messages: List[Message], new_letta_messages: List[Message], force: bool = False, clear: bool = False
     ) -> Tuple[List[Message], bool]:
         all_in_context_messages = in_context_messages + new_letta_messages
 
-        if len(all_in_context_messages) <= self.message_buffer_limit:
+        if len(all_in_context_messages) <= self.message_buffer_limit and not force:
             logger.info(
                 f"Nothing to evict, returning in context messages as is. Current buffer length is {len(all_in_context_messages)}, limit is {self.message_buffer_limit}."
             )
             return all_in_context_messages, False
 
-        logger.info("Buffer length hit, evicting messages.")
+        retain_count = 0 if clear else self.message_buffer_min
+
+        if not force:
+            logger.info(f"Buffer length hit {self.message_buffer_limit}, evicting until we retain only {retain_count} messages.")
+        else:
+            logger.info(f"Requested force summarization, evicting until we retain only {retain_count} messages.")
 
-        target_trim_index = len(all_in_context_messages) - self.message_buffer_min
+        target_trim_index = max(1, len(all_in_context_messages) - retain_count)
 
         while target_trim_index < len(all_in_context_messages) and all_in_context_messages[target_trim_index].role != MessageRole.user:
             target_trim_index += 1
 
-        updated_in_context_messages = all_in_context_messages[target_trim_index:]
+        evicted_messages = all_in_context_messages[1:target_trim_index]  # everything except sys msg
+        updated_in_context_messages = all_in_context_messages[target_trim_index:]  # may be empty
 
-        # Target trim index went beyond end of all_in_context_messages
-        if not updated_in_context_messages:
-            logger.info("Nothing to evict, returning in context messages as is.")
+        # If *no* messages were evicted we really have nothing to do
+        if not evicted_messages:
+            logger.info("Nothing to evict, returning in-context messages as-is.")
             return all_in_context_messages, False
 
         if self.summarizer_agent:
             # Only invoke if summarizer agent is passed in
-
-            evicted_messages = all_in_context_messages[1:target_trim_index]
-
             # Format
             formatted_evicted_messages = format_transcript(evicted_messages)
             formatted_in_context_messages = format_transcript(updated_in_context_messages)
 
             # TODO: This is hyperspecific to voice, generalize!
             # Update the message transcript of the memory agent
-            self.summarizer_agent.update_message_transcript(message_transcripts=formatted_evicted_messages + formatted_in_context_messages)
+            if not isinstance(self.summarizer_agent, EphemeralSummaryAgent):
+                self.summarizer_agent.update_message_transcript(
+                    message_transcripts=formatted_evicted_messages + formatted_in_context_messages
+                )
 
             # Add line numbers to the formatted messages
             offset = len(formatted_evicted_messages)
@@ -113,14 +125,28 @@ class Summarizer:
 
             evicted_messages_str = "\n".join(formatted_evicted_messages)
             in_context_messages_str = "\n".join(formatted_in_context_messages)
-            summary_request_text = f"""You’re a memory-recall helper for an AI that can only keep the last {self.message_buffer_min} messages. Scan the conversation history, focusing on messages about to drop out of that window, and write crisp notes that capture any important facts or insights about the human so they aren’t lost.
+            # Base prompt
+            prompt_header = (
+                f"You’re a memory-recall helper for an AI that can only keep the last {retain_count} messages. "
+                "Scan the conversation history, focusing on messages about to drop out of that window, "
+                "and write crisp notes that capture any important facts or insights about the conversation history so they aren’t lost."
+            )
 
-    (Older) Evicted Messages:\n
-    {evicted_messages_str}\n
+            # Sections
+            evicted_section = f"\n\n(Older) Evicted Messages:\n{evicted_messages_str}" if evicted_messages_str.strip() else ""
+            in_context_section = ""
+
+            if retain_count > 0 and in_context_messages_str.strip():
+                in_context_section = f"\n\n(Newer) In-Context Messages:\n{in_context_messages_str}"
+            elif retain_count == 0:
+                prompt_header = (
+                    "You’re a memory-recall helper for an AI that is about to forget all prior messages. "
+                    "Scan the conversation history and write crisp notes that capture any important facts or insights about the conversation history."
+                )
+
+            # Compose final prompt
+            summary_request_text = prompt_header + evicted_section + in_context_section
 
-    (Newer) In-Context Messages:\n
-    {in_context_messages_str}
-    """
             # Fire-and-forget the summarization task
             self.fire_and_forget(
                 self.summarizer_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=summary_request_text)])])
@@ -156,7 +182,8 @@ def format_transcript(messages: List[Message], include_system: bool = False) ->
             # Skip tool messages where the name is "send_message"
             if msg.role == MessageRole.tool and msg.name == DEFAULT_MESSAGE_TOOL:
                 continue
-            text = "".join(c.text for c in msg.content).strip()
+
+            text = "".join(c.text for c in msg.content if isinstance(c, TextContent)).strip()
 
         # 2) Otherwise, try extracting from function calls
         elif msg.tool_calls:

letta/services/telemetry_manager.py

@@ -38,6 +38,13 @@ class TelemetryManager:
     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())
+            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()
 

letta/services/tool_executor/tool_execution_manager.py

@@ -1,6 +1,7 @@
 import traceback
 from typing import Any, Dict, Optional, Type
 
+from letta.constants import FUNCTION_RETURN_VALUE_TRUNCATED
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState
@@ -68,8 +69,8 @@ class ToolExecutionManager:
         agent_manager: AgentManager,
         block_manager: BlockManager,
         passage_manager: PassageManager,
-        agent_state: AgentState,
         actor: User,
+        agent_state: Optional[AgentState] = None,
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
     ):
@@ -83,50 +84,6 @@ class ToolExecutionManager:
         self.sandbox_config = sandbox_config
         self.sandbox_env_vars = sandbox_env_vars
 
-    def execute_tool(self, function_name: str, function_args: dict, tool: Tool) -> ToolExecutionResult:
-        """
-        Execute a tool and persist any state changes.
-
-        Args:
-            function_name: Name of the function to execute
-            function_args: Arguments to pass to the function
-            tool: Tool object containing metadata about the tool
-
-        Returns:
-            Tuple containing the function response and sandbox run result (if applicable)
-        """
-        try:
-            executor = ToolExecutorFactory.get_executor(
-                tool.tool_type,
-                message_manager=self.message_manager,
-                agent_manager=self.agent_manager,
-                block_manager=self.block_manager,
-                passage_manager=self.passage_manager,
-                actor=self.actor,
-            )
-            return executor.execute(
-                function_name,
-                function_args,
-                self.agent_state,
-                tool,
-                self.actor,
-                self.sandbox_config,
-                self.sandbox_env_vars,
-            )
-
-        except Exception as e:
-            self.logger.error(f"Error executing tool {function_name}: {str(e)}")
-            error_message = get_friendly_error_msg(
-                function_name=function_name,
-                exception_name=type(e).__name__,
-                exception_message=str(e),
-            )
-            return ToolExecutionResult(
-                status="error",
-                func_return=error_message,
-                stderr=[traceback.format_exc()],
-            )
-
     @trace_method
     async def execute_tool_async(self, function_name: str, function_args: dict, tool: Tool) -> ToolExecutionResult:
         """
@@ -141,13 +98,15 @@ class ToolExecutionManager:
                 passage_manager=self.passage_manager,
                 actor=self.actor,
             )
-            # TODO: Extend this async model to composio
-            if isinstance(
-                executor, (SandboxToolExecutor, ExternalComposioToolExecutor, LettaBuiltinToolExecutor, LettaMultiAgentToolExecutor)
-            ):
-                result = await executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
-            else:
-                result = executor.execute(function_name, function_args, self.agent_state, tool, self.actor)
+            result = await executor.execute(
+                function_name, function_args, tool, self.actor, self.agent_state, self.sandbox_config, self.sandbox_env_vars
+            )
+
+            # trim result
+            return_str = str(result.func_return)
+            if len(return_str) > tool.return_char_limit:
+                # TODO: okay that this become a string?
+                result.func_return = FUNCTION_RETURN_VALUE_TRUNCATED(return_str, len(return_str), tool.return_char_limit)
             return result
 
         except Exception as e:

letta/services/tool_executor/tool_execution_sandbox.py

@@ -1,4 +1,3 @@
-import ast
 import base64
 import io
 import os
@@ -23,6 +22,7 @@ from letta.services.helpers.tool_execution_helper import (
     find_python_executable,
     install_pip_requirements_for_sandbox,
 )
+from letta.services.helpers.tool_parser_helper import convert_param_to_str_value, parse_function_arguments
 from letta.services.organization_manager import OrganizationManager
 from letta.services.sandbox_config_manager import SandboxConfigManager
 from letta.services.tool_manager import ToolManager
@@ -52,7 +52,6 @@ class ToolExecutionSandbox:
         self.tool_name = tool_name
         self.args = args
         self.user = user
-        # get organization
         self.organization = OrganizationManager().get_organization_by_id(self.user.organization_id)
         self.privileged_tools = self.organization.privileged_tools
 
@@ -476,16 +475,6 @@ class ToolExecutionSandbox:
             agent_state = result["agent_state"]
         return result["results"], agent_state
 
-    def parse_function_arguments(self, source_code: str, tool_name: str):
-        """Get arguments of a function from its source code"""
-        tree = ast.parse(source_code)
-        args = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef) and node.name == tool_name:
-                for arg in node.args.args:
-                    args.append(arg.arg)
-        return args
-
     def generate_execution_script(self, agent_state: AgentState, wrap_print_with_markers: bool = False) -> str:
         """
         Generate code to run inside of execution sandbox.
@@ -498,7 +487,7 @@ class ToolExecutionSandbox:
         Returns:
             code (str): The generated code strong
         """
-        if "agent_state" in self.parse_function_arguments(self.tool.source_code, self.tool.name):
+        if "agent_state" in parse_function_arguments(self.tool.source_code, self.tool.name):
             inject_agent_state = True
         else:
             inject_agent_state = False
@@ -546,7 +535,7 @@ class ToolExecutionSandbox:
         code += (
             self.LOCAL_SANDBOX_RESULT_VAR_NAME
             + ' = {"results": '
-            + self.invoke_function_call(inject_agent_state=inject_agent_state)
+            + self.invoke_function_call(inject_agent_state=inject_agent_state)  # this inject_agent_state is the main difference
             + ', "agent_state": agent_state}\n'
         )
         code += (
@@ -562,24 +551,6 @@ class ToolExecutionSandbox:
 
         return code
 
-    def _convert_param_to_value(self, param_type: str, raw_value: str) -> str:
-
-        if param_type == "string":
-            value = "pickle.loads(" + str(pickle.dumps(raw_value)) + ")"
-
-        elif param_type == "integer" or param_type == "boolean" or param_type == "number":
-            value = raw_value
-
-        elif param_type == "array":
-            value = raw_value
-
-        elif param_type == "object":
-            value = raw_value
-
-        else:
-            raise TypeError(f"Unsupported type: {param_type}, raw_value={raw_value}")
-        return str(value)
-
     def initialize_param(self, name: str, raw_value: str) -> str:
         params = self.tool.json_schema["parameters"]["properties"]
         spec = params.get(name)
@@ -591,8 +562,7 @@ class ToolExecutionSandbox:
         if param_type is None and spec.get("parameters"):
             param_type = spec["parameters"].get("type")
 
-        value = self._convert_param_to_value(param_type, raw_value)
-
+        value = convert_param_to_str_value(param_type, raw_value)
         return name + " = " + value + "\n"
 
     def invoke_function_call(self, inject_agent_state: bool) -> str: