letta-nightly 0.7.10.dev20250507104304__py3-none-any.whl → 0.7.12.dev20250508044425__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -331,10 +331,9 @@ class Agent(BaseAgent):
                 log_telemetry(self.logger, "_get_ai_reply create start")
                 # New LLM client flow
                 llm_client = LLMClient.create(
-                    provider_name=self.agent_state.llm_config.provider_name,
                     provider_type=self.agent_state.llm_config.model_endpoint_type,
                     put_inner_thoughts_first=put_inner_thoughts_first,
-                    actor_id=self.user.id,
+                    actor=self.user,
                 )
 
                 if llm_client and not stream:
@@ -943,7 +942,10 @@ class Agent(BaseAgent):
                 model_endpoint=self.agent_state.llm_config.model_endpoint,
                 context_window_limit=self.agent_state.llm_config.context_window,
                 usage=response.usage,
-                provider_id=self.provider_manager.get_provider_id_from_name(self.agent_state.llm_config.provider_name),
+                provider_id=self.provider_manager.get_provider_id_from_name(
+                    self.agent_state.llm_config.provider_name,
+                    actor=self.user,
+                ),
                 job_id=job_id,
             )
             for message in all_new_messages:
@@ -1087,7 +1089,9 @@ class Agent(BaseAgent):
                 LLM_MAX_TOKENS[self.model] if (self.model is not None and self.model in LLM_MAX_TOKENS) else LLM_MAX_TOKENS["DEFAULT"]
             )
 
-        summary = summarize_messages(agent_state=self.agent_state, message_sequence_to_summarize=message_sequence_to_summarize)
+        summary = summarize_messages(
+            agent_state=self.agent_state, message_sequence_to_summarize=message_sequence_to_summarize, actor=self.user
+        )
         logger.info(f"Got summary: {summary}")
 
         # Metadata that's useful for the agent to see

letta/agents/letta_agent.py

@@ -75,10 +75,9 @@ class LettaAgent(BaseAgent):
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
-            provider_name=agent_state.llm_config.provider_name,
             provider_type=agent_state.llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
-            actor_id=self.actor.id,
+            actor=self.actor,
         )
         for _ in range(max_steps):
             response = await self._get_ai_reply(
@@ -120,10 +119,9 @@ class LettaAgent(BaseAgent):
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
-            provider_name=agent_state.llm_config.provider_name,
             provider_type=agent_state.llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
-            actor_id=self.actor.id,
+            actor=self.actor,
         )
 
         for _ in range(max_steps):
@@ -350,7 +348,7 @@ class LettaAgent(BaseAgent):
                 results = await self._send_message_to_agents_matching_tags(**tool_args)
                 log_event(name="finish_send_message_to_agents_matching_tags", attributes=tool_args)
                 return json.dumps(results), True
-            elif target_tool.type == ToolType.EXTERNAL_COMPOSIO:
+            elif target_tool.tool_type == ToolType.EXTERNAL_COMPOSIO:
                 log_event(name=f"start_composio_{tool_name}_execution", attributes=tool_args)
                 log_event(name=f"finish_compsio_{tool_name}_execution", attributes=tool_args)
                 return tool_execution_result.func_return, True

letta/agents/letta_agent_batch.py

@@ -172,10 +172,9 @@ class LettaAgentBatch:
 
         log_event(name="init_llm_client")
         llm_client = LLMClient.create(
-            provider_name=agent_states[0].llm_config.provider_name,
             provider_type=agent_states[0].llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
-            actor_id=self.actor.id,
+            actor=self.actor,
         )
         agent_llm_config_mapping = {s.id: s.llm_config for s in agent_states}
 
@@ -284,10 +283,9 @@ class LettaAgentBatch:
 
             # translate provider‑specific response → OpenAI‑style tool call (unchanged)
             llm_client = LLMClient.create(
-                provider_name=item.llm_config.provider_name,
                 provider_type=item.llm_config.model_endpoint_type,
                 put_inner_thoughts_first=True,
-                actor_id=self.actor.id,
+                actor=self.actor,
             )
             tool_call = (
                 llm_client.convert_response_to_chat_completion(

letta/client/client.py

@@ -3455,7 +3455,7 @@ class LocalClient(AbstractClient):
         Returns:
             configs (List[LLMConfig]): List of LLM configurations
         """
-        return self.server.list_llm_models()
+        return self.server.list_llm_models(actor=self.user)
 
     def list_embedding_configs(self) -> List[EmbeddingConfig]:
         """
@@ -3464,7 +3464,7 @@ class LocalClient(AbstractClient):
         Returns:
             configs (List[EmbeddingConfig]): List of embedding configurations
         """
-        return self.server.list_embedding_models()
+        return self.server.list_embedding_models(actor=self.user)
 
     def create_org(self, name: Optional[str] = None) -> Organization:
         return self.server.organization_manager.create_organization(pydantic_org=Organization(name=name))

letta/functions/async_composio_toolset.py

@@ -0,0 +1,106 @@
+import json
+from typing import Any
+
+import aiohttp
+from composio import ComposioToolSet as BaseComposioToolSet
+from composio.exceptions import (
+    ApiKeyNotProvidedError,
+    ComposioSDKError,
+    ConnectedAccountNotFoundError,
+    EnumMetadataNotFound,
+    EnumStringNotFound,
+)
+
+
+class AsyncComposioToolSet(BaseComposioToolSet, runtime="letta"):
+    """
+    Async version of ComposioToolSet client for interacting with Composio API
+    Used to asynchronously hit the execute action endpoint
+
+    https://docs.composio.dev/api-reference/api-reference/v3/tools/post-api-v-3-tools-execute-action
+    """
+
+    def __init__(self, api_key: str, entity_id: str, lock: bool = True):
+        """
+        Initialize the AsyncComposioToolSet client
+
+        Args:
+            api_key (str): Your Composio API key
+            entity_id (str): Your Composio entity ID
+            lock (bool): Whether to use locking (default: True)
+        """
+        super().__init__(api_key=api_key, entity_id=entity_id, lock=lock)
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-API-Key": self._api_key,
+        }
+
+    async def execute_action(
+        self,
+        action: str,
+        params: dict[str, Any] = {},
+    ) -> dict[str, Any]:
+        """
+        Execute an action asynchronously using the Composio API
+
+        Args:
+            action (str): The name of the action to execute
+            params (dict[str, Any], optional): Parameters for the action
+
+        Returns:
+            dict[str, Any]: The API response
+
+        Raises:
+            ApiKeyNotProvidedError: if the API key is not provided
+            ComposioSDKError: if a general Composio SDK error occurs
+            ConnectedAccountNotFoundError: if the connected account is not found
+            EnumMetadataNotFound: if enum metadata is not found
+            EnumStringNotFound: if enum string is not found
+            aiohttp.ClientError: if a network-related error occurs
+            ValueError: if an error with the parameters or response occurs
+        """
+        API_VERSION = "v3"
+        endpoint = f"{self._base_url}/{API_VERSION}/tools/execute/{action}"
+
+        json_payload = {
+            "entity_id": self.entity_id,
+            "arguments": params or {},
+        }
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(endpoint, headers=self.headers, json=json_payload) as response:
+                    print(response, response.status, response.reason, response.content)
+                    if response.status == 200:
+                        return await response.json()
+                    else:
+                        error_text = await response.text()
+                        try:
+                            error_json = json.loads(error_text)
+                            error_message = error_json.get("message", error_text)
+                            error_code = error_json.get("code")
+
+                            # Handle specific error codes from Composio API
+                            if error_code == 10401 or "API_KEY_NOT_FOUND" in error_message:
+                                raise ApiKeyNotProvidedError()
+                            if "connected account not found" in error_message.lower():
+                                raise ConnectedAccountNotFoundError(f"Connected account not found: {error_message}")
+                            if "enum metadata not found" in error_message.lower():
+                                raise EnumMetadataNotFound(f"Enum metadata not found: {error_message}")
+                            if "enum string not found" in error_message.lower():
+                                raise EnumStringNotFound(f"Enum string not found: {error_message}")
+                        except json.JSONDecodeError:
+                            error_message = error_text
+
+                        # If no specific error was identified, raise a general error
+                        raise ValueError(f"API request failed with status {response.status}: {error_message}")
+        except aiohttp.ClientError as e:
+            # Wrap network errors in ComposioSDKError
+            raise ComposioSDKError(f"Network error when calling Composio API: {str(e)}")
+        except ValueError:
+            # Re-raise ValueError (which could be our custom error message or a JSON parsing error)
+            raise
+        except Exception as e:
+            # Catch any other exceptions and wrap them in ComposioSDKError
+            raise ComposioSDKError(f"Unexpected error when calling Composio API: {str(e)}")

letta/functions/composio_helpers.py

@@ -1,8 +1,6 @@
-import asyncio
 import os
 from typing import Any, Optional
 
-from composio import ComposioToolSet
 from composio.constants import DEFAULT_ENTITY_ID
 from composio.exceptions import (
     ApiKeyNotProvidedError,
@@ -13,6 +11,8 @@ from composio.exceptions import (
 )
 
 from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY
+from letta.functions.async_composio_toolset import AsyncComposioToolSet
+from letta.utils import run_async_task
 
 
 # TODO: This is kind of hacky, as this is used to search up the action later on composio's side
@@ -61,38 +61,34 @@ def {func_name}(**kwargs):
 async def execute_composio_action_async(
     action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None
 ) -> tuple[str, str]:
-    try:
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, execute_composio_action, action_name, args, api_key, entity_id)
-    except Exception as e:
-        raise RuntimeError(f"Error in execute_composio_action_async: {e}") from e
-
-
-def execute_composio_action(action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None) -> Any:
     entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
+    composio_toolset = AsyncComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
     try:
-        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id, lock=False)
-        response = composio_toolset.execute_action(action=action_name, params=args)
-    except ApiKeyNotProvidedError:
-        raise RuntimeError(
-            f"Composio API key is missing for action '{action_name}'. "
-            "Please set the sandbox environment variables either through the ADE or the API."
-        )
-    except ConnectedAccountNotFoundError:
-        raise RuntimeError(f"No connected account was found for action '{action_name}'. " "Please link an account and try again.")
-    except EnumStringNotFound as e:
-        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+        response = await composio_toolset.execute_action(action=action_name, params=args)
+    except ApiKeyNotProvidedError as e:
+        raise RuntimeError(f"API key not provided or invalid for Composio action '{action_name}': {str(e)}")
+    except ConnectedAccountNotFoundError as e:
+        raise RuntimeError(f"Connected account not found for Composio action '{action_name}': {str(e)}")
     except EnumMetadataNotFound as e:
-        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+        raise RuntimeError(f"Enum metadata not found for Composio action '{action_name}': {str(e)}")
+    except EnumStringNotFound as e:
+        raise RuntimeError(f"Enum string not found for Composio action '{action_name}': {str(e)}")
     except ComposioSDKError as e:
-        raise RuntimeError(f"An unexpected error occurred in Composio SDK while executing action '{action_name}': " + str(e))
+        raise RuntimeError(f"Composio SDK error while executing action '{action_name}': {str(e)}")
+    except Exception as e:
+        print(type(e))
+        raise RuntimeError(f"An unexpected error occurred in Composio SDK while executing action '{action_name}': {str(e)}")
 
     if "error" in response and response["error"]:
-        raise RuntimeError(f"Error while executing action '{action_name}': " + str(response["error"]))
+        raise RuntimeError(f"Error while executing action '{action_name}': {str(response['error'])}")
 
     return response.get("data")
 
 
+def execute_composio_action(action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None) -> Any:
+    return run_async_task(execute_composio_action_async(action_name, args, api_key, entity_id))
+
+
 def _assert_code_gen_compilable(code_str):
     try:
         compile(code_str, "<string>", "exec")

letta/llm_api/anthropic.py

@@ -19,14 +19,14 @@ from anthropic.types.beta import (
     BetaToolUseBlock,
 )
 
-from letta.errors import BedrockError, BedrockPermissionError
+from letta.errors import BedrockError, BedrockPermissionError, ErrorCode, LLMAuthenticationError, LLMError
 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
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.log import get_logger
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderCategory
 from letta.schemas.message import Message as _Message
 from letta.schemas.message import MessageRole as _MessageRole
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
@@ -42,6 +42,7 @@ from letta.schemas.openai.chat_completion_response import Message
 from letta.schemas.openai.chat_completion_response import Message as ChoiceMessage
 from letta.schemas.openai.chat_completion_response import MessageDelta, ToolCall, ToolCallDelta, UsageStatistics
 from letta.services.provider_manager import ProviderManager
+from letta.services.user_manager import UserManager
 from letta.settings import model_settings
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
 from letta.tracing import log_event
@@ -118,6 +119,20 @@ DUMMY_FIRST_USER_MESSAGE = "User initializing bootup sequence."
 VALID_EVENT_TYPES = {"content_block_stop", "message_stop"}
 
 
+def anthropic_check_valid_api_key(api_key: Union[str, None]) -> None:
+    if api_key:
+        anthropic_client = anthropic.Anthropic(api_key=api_key)
+        try:
+            # just use a cheap model to count some tokens - as of 5/7/2025 this is faster than fetching the list of models
+            anthropic_client.messages.count_tokens(model=MODEL_LIST[-1]["name"], messages=[{"role": "user", "content": "a"}])
+        except anthropic.AuthenticationError as e:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Anthropic: {e}", code=ErrorCode.UNAUTHENTICATED)
+        except Exception as e:
+            raise LLMError(message=f"{e}", code=ErrorCode.INTERNAL_SERVER_ERROR)
+    else:
+        raise ValueError("No API key provided")
+
+
 def antropic_get_model_context_window(url: str, api_key: Union[str, None], model: str) -> int:
     for model_dict in anthropic_get_model_list(url=url, api_key=api_key):
         if model_dict["name"] == model:
@@ -744,12 +759,15 @@ def anthropic_chat_completions_request(
     extended_thinking: bool = False,
     max_reasoning_tokens: Optional[int] = None,
     provider_name: Optional[str] = None,
+    provider_category: Optional[ProviderCategory] = None,
     betas: List[str] = ["tools-2024-04-04"],
+    user_id: Optional[str] = None,
 ) -> ChatCompletionResponse:
     """https://docs.anthropic.com/claude/docs/tool-use"""
     anthropic_client = None
-    if provider_name and provider_name != ProviderType.anthropic.value:
-        api_key = ProviderManager().get_override_key(provider_name)
+    if provider_category == ProviderCategory.byok:
+        actor = UserManager().get_user_or_default(user_id=user_id)
+        api_key = ProviderManager().get_override_key(provider_name, actor=actor)
         anthropic_client = anthropic.Anthropic(api_key=api_key)
     elif model_settings.anthropic_api_key:
         anthropic_client = anthropic.Anthropic()
@@ -803,7 +821,9 @@ def anthropic_chat_completions_request_stream(
     extended_thinking: bool = False,
     max_reasoning_tokens: Optional[int] = None,
     provider_name: Optional[str] = None,
+    provider_category: Optional[ProviderCategory] = None,
     betas: List[str] = ["tools-2024-04-04"],
+    user_id: Optional[str] = None,
 ) -> Generator[ChatCompletionChunkResponse, None, None]:
     """Stream chat completions from Anthropic API.
 
@@ -817,8 +837,9 @@ def anthropic_chat_completions_request_stream(
         extended_thinking=extended_thinking,
         max_reasoning_tokens=max_reasoning_tokens,
     )
-    if provider_name and provider_name != ProviderType.anthropic.value:
-        api_key = ProviderManager().get_override_key(provider_name)
+    if provider_category == ProviderCategory.byok:
+        actor = UserManager().get_user_or_default(user_id=user_id)
+        api_key = ProviderManager().get_override_key(provider_name, actor=actor)
         anthropic_client = anthropic.Anthropic(api_key=api_key)
     elif model_settings.anthropic_api_key:
         anthropic_client = anthropic.Anthropic()
@@ -867,10 +888,12 @@ def anthropic_chat_completions_process_stream(
     extended_thinking: bool = False,
     max_reasoning_tokens: Optional[int] = None,
     provider_name: Optional[str] = None,
+    provider_category: Optional[ProviderCategory] = None,
     create_message_id: bool = True,
     create_message_datetime: bool = True,
     betas: List[str] = ["tools-2024-04-04"],
     name: Optional[str] = None,
+    user_id: Optional[str] = None,
 ) -> ChatCompletionResponse:
     """Process a streaming completion response from Anthropic, similar to OpenAI's streaming.
 
@@ -952,7 +975,9 @@ def anthropic_chat_completions_process_stream(
                 extended_thinking=extended_thinking,
                 max_reasoning_tokens=max_reasoning_tokens,
                 provider_name=provider_name,
+                provider_category=provider_category,
                 betas=betas,
+                user_id=user_id,
             )
         ):
             assert isinstance(chat_completion_chunk, ChatCompletionChunkResponse), type(chat_completion_chunk)

letta/llm_api/anthropic_client.py

@@ -27,7 +27,7 @@ from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_in
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
 from letta.log import get_logger
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderCategory
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import Tool
@@ -45,18 +45,18 @@ logger = get_logger(__name__)
 class AnthropicClient(LLMClientBase):
 
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
-        client = self._get_anthropic_client(async_client=False)
+        client = self._get_anthropic_client(llm_config, async_client=False)
         response = client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
         return response.model_dump()
 
     async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
-        client = self._get_anthropic_client(async_client=True)
+        client = self._get_anthropic_client(llm_config, async_client=True)
         response = await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
         return response.model_dump()
 
     @trace_method
     async def stream_async(self, request_data: dict, llm_config: LLMConfig) -> AsyncStream[BetaRawMessageStreamEvent]:
-        client = self._get_anthropic_client(async_client=True)
+        client = self._get_anthropic_client(llm_config, async_client=True)
         request_data["stream"] = True
         return await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
 
@@ -96,7 +96,7 @@ class AnthropicClient(LLMClientBase):
                 for agent_id in agent_messages_mapping
             }
 
-            client = self._get_anthropic_client(async_client=True)
+            client = self._get_anthropic_client(list(agent_llm_config_mapping.values())[0], async_client=True)
 
             anthropic_requests = [
                 Request(custom_id=agent_id, params=MessageCreateParamsNonStreaming(**params)) for agent_id, params in requests.items()
@@ -112,10 +112,12 @@ class AnthropicClient(LLMClientBase):
             raise self.handle_llm_error(e)
 
     @trace_method
-    def _get_anthropic_client(self, async_client: bool = False) -> Union[anthropic.AsyncAnthropic, anthropic.Anthropic]:
+    def _get_anthropic_client(
+        self, llm_config: LLMConfig, async_client: bool = False
+    ) -> Union[anthropic.AsyncAnthropic, anthropic.Anthropic]:
         override_key = None
-        if self.provider_name and self.provider_name != ProviderType.anthropic.value:
-            override_key = ProviderManager().get_override_key(self.provider_name)
+        if llm_config.provider_category == ProviderCategory.byok:
+            override_key = ProviderManager().get_override_key(llm_config.provider_name, actor=self.actor)
 
         if async_client:
             return anthropic.AsyncAnthropic(api_key=override_key) if override_key else anthropic.AsyncAnthropic()

letta/llm_api/google_ai_client.py

@@ -3,17 +3,20 @@ import uuid
 from typing import List, Optional, Tuple
 
 import requests
+from google import genai
 from google.genai.types import FunctionCallingConfig, FunctionCallingConfigMode, ToolConfig
 
 from letta.constants import NON_USER_MSG_PREFIX
+from letta.errors import ErrorCode, LLMAuthenticationError, LLMError
 from letta.helpers.datetime_helpers import get_utc_time_int
 from letta.helpers.json_helpers import json_dumps
+from letta.llm_api.google_constants import GOOGLE_MODEL_FOR_API_KEY_CHECK
 from letta.llm_api.helpers import make_post_request
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.log import get_logger
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderCategory
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import Tool
@@ -31,10 +34,10 @@ class GoogleAIClient(LLMClientBase):
         Performs underlying request to llm and returns raw response.
         """
         api_key = None
-        if llm_config.provider_name and llm_config.provider_name != ProviderType.google_ai.value:
+        if llm_config.provider_category == ProviderCategory.byok:
             from letta.services.provider_manager import ProviderManager
 
-            api_key = ProviderManager().get_override_key(llm_config.provider_name)
+            api_key = ProviderManager().get_override_key(llm_config.provider_name, actor=self.actor)
 
         if not api_key:
             api_key = model_settings.gemini_api_key
@@ -165,10 +168,12 @@ class GoogleAIClient(LLMClientBase):
 
                         # NOTE: this also involves stripping the inner monologue out of the function
                         if llm_config.put_inner_thoughts_in_kwargs:
-                            from letta.local_llm.constants import INNER_THOUGHTS_KWARG
+                            from letta.local_llm.constants import INNER_THOUGHTS_KWARG_VERTEX
 
-                            assert INNER_THOUGHTS_KWARG in function_args, f"Couldn't find inner thoughts in function args:\n{function_call}"
-                            inner_thoughts = function_args.pop(INNER_THOUGHTS_KWARG)
+                            assert (
+                                INNER_THOUGHTS_KWARG_VERTEX in function_args
+                            ), f"Couldn't find inner thoughts in function args:\n{function_call}"
+                            inner_thoughts = function_args.pop(INNER_THOUGHTS_KWARG_VERTEX)
                             assert inner_thoughts is not None, f"Expected non-null inner thoughts function arg:\n{function_call}"
                         else:
                             inner_thoughts = None
@@ -288,7 +293,7 @@ class GoogleAIClient(LLMClientBase):
         # Per https://ai.google.dev/gemini-api/docs/function-calling?example=meeting#notes_and_limitations
         # * Only a subset of the OpenAPI schema is supported.
         # * Supported parameter types in Python are limited.
-        unsupported_keys = ["default", "exclusiveMaximum", "exclusiveMinimum"]
+        unsupported_keys = ["default", "exclusiveMaximum", "exclusiveMinimum", "additionalProperties"]
         keys_to_remove_at_this_level = [key for key in unsupported_keys if key in schema_part]
         for key_to_remove in keys_to_remove_at_this_level:
             logger.warning(f"Removing unsupported keyword 	'{key_to_remove}' from schema part.")
@@ -380,13 +385,13 @@ class GoogleAIClient(LLMClientBase):
 
             # Add inner thoughts
             if llm_config.put_inner_thoughts_in_kwargs:
-                from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
+                from letta.local_llm.constants import INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_VERTEX
 
-                func["parameters"]["properties"][INNER_THOUGHTS_KWARG] = {
+                func["parameters"]["properties"][INNER_THOUGHTS_KWARG_VERTEX] = {
                     "type": "string",
                     "description": INNER_THOUGHTS_KWARG_DESCRIPTION,
                 }
-                func["parameters"]["required"].append(INNER_THOUGHTS_KWARG)
+                func["parameters"]["required"].append(INNER_THOUGHTS_KWARG_VERTEX)
 
         return [{"functionDeclarations": function_list}]
 
@@ -441,6 +446,23 @@ def get_gemini_endpoint_and_headers(
     return url, headers
 
 
+def google_ai_check_valid_api_key(api_key: str):
+    client = genai.Client(api_key=api_key)
+    # use the count token endpoint for a cheap model - as of 5/7/2025 this is slightly faster than fetching the list of models
+    try:
+        client.models.count_tokens(
+            model=GOOGLE_MODEL_FOR_API_KEY_CHECK,
+            contents="",
+        )
+    except genai.errors.ClientError as e:
+        # google api returns 400 invalid argument for invalid api key
+        if e.code == 400:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Google AI: {e}", code=ErrorCode.UNAUTHENTICATED)
+        raise e
+    except Exception as e:
+        raise LLMError(message=f"{e}", code=ErrorCode.INTERNAL_SERVER_ERROR)
+
+
 def google_ai_get_model_list(base_url: str, api_key: str, key_in_header: bool = True) -> List[dict]:
     from letta.utils import printd
 

letta/llm_api/google_constants.py

@@ -14,3 +14,5 @@ GOOGLE_MODEL_TO_CONTEXT_LENGTH = {
 GOOGLE_MODEL_TO_OUTPUT_LENGTH = {"gemini-2.0-flash-001": 8192, "gemini-2.5-pro-exp-03-25": 65536}
 
 GOOGLE_EMBEDING_MODEL_TO_DIM = {"text-embedding-005": 768, "text-multilingual-embedding-002": 768}
+
+GOOGLE_MODEL_FOR_API_KEY_CHECK = "gemini-2.0-flash-lite"