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

letta/services/tool_sandbox/e2b_sandbox.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from e2b.sandbox.commands.command_handle import CommandExitException
@@ -43,6 +44,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         agent_state: Optional[AgentState] = None,
         additional_env_vars: Optional[Dict] = None,
     ) -> ToolExecutionResult:
+        await self._init_async()
         if self.provided_sandbox_config:
             sbx_config = self.provided_sandbox_config
         else:
@@ -65,14 +67,24 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
         code = await self.generate_execution_script(agent_state=agent_state)
 
         try:
+            logger.info(f"E2B execution started for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
             log_event(
                 "e2b_execution_started",
                 {"tool": self.tool_name, "sandbox_id": e2b_sandbox.sandbox_id, "code": code, "env_vars": envs},
             )
-            execution = await e2b_sandbox.run_code(code, envs=envs)
+            try:
+                execution = await e2b_sandbox.run_code(code, envs=envs)
+            except asyncio.CancelledError:
+                logger.info(f"E2B execution cancelled for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
+                log_event(
+                    "e2b_execution_cancelled",
+                    {"tool": self.tool_name, "sandbox_id": e2b_sandbox.sandbox_id},
+                )
+                raise Exception("Execution cancelled. Transient failure, please retry.")
 
             if execution.results:
                 func_return, agent_state = parse_stdout_best_effort(execution.results[0].text)
+                logger.info(f"E2B execution succeeded for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
                 log_event(
                     "e2b_execution_succeeded",
                     {
@@ -90,6 +102,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                     function_name=self.tool_name, exception_name=execution.error.name, exception_message=execution.error.value
                 )
                 execution.logs.stderr.append(execution.error.traceback)
+                logger.info(f"E2B execution failed for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
                 log_event(
                     "e2b_execution_failed",
                     {
@@ -101,6 +114,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                     },
                 )
             else:
+                logger.info(f"E2B execution empty for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
                 log_event(
                     "e2b_execution_empty",
                     {
@@ -120,6 +134,7 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                 sandbox_config_fingerprint=sbx_config.fingerprint(),
             )
         finally:
+            logger.info(f"E2B sandbox {e2b_sandbox.sandbox_id} killed")
             await e2b_sandbox.kill()
 
     @staticmethod

letta/services/tool_schema_generator.py

@@ -0,0 +1,123 @@
+"""Schema generation utilities for tool creation and updates."""
+
+from typing import Optional
+
+from letta.functions.ast_parsers import get_function_name_and_docstring
+from letta.functions.functions import derive_openai_json_schema
+from letta.functions.helpers import generate_model_from_args_json_schema
+from letta.functions.schema_generator import generate_schema_from_args_schema_v2
+from letta.log import get_logger
+from letta.schemas.enums import ToolSourceType, ToolType
+from letta.schemas.tool import Tool as PydanticTool
+
+logger = get_logger(__name__)
+
+
+def generate_schema_for_tool_creation(
+    tool: PydanticTool,
+) -> Optional[dict]:
+    """
+    Generate JSON schema for tool creation based on the provided parameters.
+
+    Args:
+        tool: The tool being created
+
+    Returns:
+        Generated JSON schema or None if not applicable
+    """
+    # Only generate schema for custom tools
+    if tool.tool_type != ToolType.CUSTOM:
+        return None
+
+    # If json_schema is already provided, use it
+    if tool.json_schema:
+        return tool.json_schema
+
+    # Must have source code for custom tools
+    if not tool.source_code:
+        logger.error("Custom tool is missing source_code field")
+        raise ValueError("Custom tool is missing source_code field.")
+
+    # TypeScript tools
+    if tool.source_type == ToolSourceType.typescript:
+        try:
+            from letta.functions.typescript_parser import derive_typescript_json_schema
+
+            return derive_typescript_json_schema(source_code=tool.source_code)
+        except Exception as e:
+            logger.error(f"Failed to derive TypeScript json schema: {e}")
+            raise ValueError(f"Failed to derive TypeScript json schema: {e}")
+
+    # Python tools (default if not specified for backwards compatibility)
+    elif tool.source_type == ToolSourceType.python or tool.source_type is None:
+        # If args_json_schema is provided, use it to generate full schema
+        if tool.args_json_schema:
+            name, description = get_function_name_and_docstring(tool.source_code, tool.name)
+            args_schema = generate_model_from_args_json_schema(tool.args_json_schema)
+            return generate_schema_from_args_schema_v2(
+                args_schema=args_schema,
+                name=name,
+                description=description,
+                append_heartbeat=False,
+            )
+        # Otherwise, attempt to parse from docstring with best effort
+        else:
+            try:
+                return derive_openai_json_schema(source_code=tool.source_code)
+            except Exception as e:
+                logger.error(f"Failed to derive json schema: {e}")
+                raise ValueError(f"Failed to derive json schema: {e}")
+    else:
+        # TODO: convert to explicit error
+        raise ValueError(f"Unknown tool source type: {tool.source_type}")
+
+
+def generate_schema_for_tool_update(
+    current_tool: PydanticTool,
+    json_schema: Optional[dict] = None,
+    args_json_schema: Optional[dict] = None,
+    source_code: Optional[str] = None,
+    source_type: Optional[ToolSourceType] = None,
+) -> Optional[dict]:
+    """
+    Generate JSON schema for tool update based on the provided parameters.
+
+    Args:
+        current_tool: The current tool being updated
+        json_schema: Directly provided JSON schema (takes precedence)
+        args_json_schema: Schema for just the arguments
+        source_code: Updated source code (only used if explicitly updating source)
+        source_type: Source type for the tool
+
+    Returns:
+        Updated JSON schema or None if no update needed
+    """
+    # Only handle custom tools
+    if current_tool.tool_type != ToolType.CUSTOM:
+        return None
+
+    # If json_schema is directly provided, use it
+    if json_schema is not None:
+        # If args_json_schema is also provided, that's an error
+        if args_json_schema is not None:
+            raise ValueError("Cannot provide both json_schema and args_json_schema in update")
+        return json_schema
+
+    # If args_json_schema is provided, generate full schema from it
+    if args_json_schema is not None:
+        # Use updated source_code if provided, otherwise use current
+        code_to_parse = source_code if source_code is not None else current_tool.source_code
+        if not code_to_parse:
+            raise ValueError("Source code required when updating with args_json_schema")
+
+        name, description = get_function_name_and_docstring(code_to_parse, current_tool.name)
+        args_schema = generate_model_from_args_json_schema(args_json_schema)
+        return generate_schema_from_args_schema_v2(
+            args_schema=args_schema,
+            name=name,
+            description=description,
+            append_heartbeat=False,
+        )
+
+    # Otherwise, no schema updates (don't parse docstring)
+    return None

letta/services/user_manager.py

@@ -23,27 +23,6 @@ class UserManager:
     DEFAULT_USER_NAME = "default_user"
     DEFAULT_USER_ID = "user-00000000-0000-4000-8000-000000000000"
 
-    @enforce_types
-    @trace_method
-    def create_default_user(self, org_id: str = DEFAULT_ORG_ID) -> PydanticUser:
-        """Create the default user."""
-        with db_registry.session() as session:
-            # Make sure the org id exists
-            try:
-                OrganizationModel.read(db_session=session, identifier=org_id)
-            except NoResultFound:
-                raise ValueError(f"No organization with {org_id} exists in the organization table.")
-
-            # Try to retrieve the user
-            try:
-                user = UserModel.read(db_session=session, identifier=self.DEFAULT_USER_ID)
-            except NoResultFound:
-                # If it doesn't exist, make it
-                user = UserModel(id=self.DEFAULT_USER_ID, name=self.DEFAULT_USER_NAME, organization_id=org_id)
-                user.create(session)
-
-            return user.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_default_actor_async(self, org_id: str = DEFAULT_ORG_ID) -> PydanticUser:
@@ -66,15 +45,6 @@ class UserManager:
 
             return actor.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def create_user(self, pydantic_user: PydanticUser) -> PydanticUser:
-        """Create a new user if it doesn't already exist."""
-        with db_registry.session() as session:
-            new_user = UserModel(**pydantic_user.model_dump(to_orm=True))
-            new_user.create(session)
-            return new_user.to_pydantic()
-
     @enforce_types
     @trace_method
     async def create_actor_async(self, pydantic_user: PydanticUser) -> PydanticUser:
@@ -85,23 +55,6 @@ class UserManager:
             await self._invalidate_actor_cache(new_user.id)
             return new_user.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def update_user(self, user_update: UserUpdate) -> PydanticUser:
-        """Update user details."""
-        with db_registry.session() as session:
-            # Retrieve the existing user by ID
-            existing_user = UserModel.read(db_session=session, identifier=user_update.id)
-
-            # Update only the fields that are provided in UserUpdate
-            update_data = user_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-            for key, value in update_data.items():
-                setattr(existing_user, key, value)
-
-            # Commit the updated user
-            existing_user.update(session)
-            return existing_user.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_actor_async(self, user_update: UserUpdate) -> PydanticUser:
@@ -120,17 +73,6 @@ class UserManager:
             await self._invalidate_actor_cache(user_update.id)
             return existing_user.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def delete_user_by_id(self, user_id: str):
-        """Delete a user and their associated records (agents, sources, mappings)."""
-        with db_registry.session() as session:
-            # Delete from user table
-            user = UserModel.read(db_session=session, identifier=user_id)
-            user.hard_delete(session)
-
-            session.commit()
-
     @enforce_types
     @trace_method
     async def delete_actor_by_id_async(self, user_id: str):
@@ -141,14 +83,6 @@ class UserManager:
             await user.hard_delete_async(session)
             await self._invalidate_actor_cache(user_id)
 
-    @enforce_types
-    @trace_method
-    def get_user_by_id(self, user_id: str) -> PydanticUser:
-        """Fetch a user by ID."""
-        with db_registry.session() as session:
-            user = UserModel.read(db_session=session, identifier=user_id)
-            return user.to_pydantic()
-
     @enforce_types
     @trace_method
     @async_redis_cache(key_func=lambda self, actor_id: f"actor_id:{actor_id}", model_class=PydanticUser)
@@ -164,27 +98,6 @@ class UserManager:
 
             return user.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def get_default_user(self) -> PydanticUser:
-        """Fetch the default user. If it doesn't exist, create it."""
-        try:
-            return self.get_user_by_id(self.DEFAULT_USER_ID)
-        except NoResultFound:
-            return self.create_default_user()
-
-    @enforce_types
-    @trace_method
-    def get_user_or_default(self, user_id: Optional[str] = None):
-        """Fetch the user or default user."""
-        if not user_id:
-            return self.get_default_user()
-
-        try:
-            return self.get_user_by_id(user_id=user_id)
-        except NoResultFound:
-            return self.get_default_user()
-
     @enforce_types
     @trace_method
     async def get_default_actor_async(self) -> PydanticUser:
@@ -206,18 +119,6 @@ class UserManager:
             user = await self.create_default_actor_async(org_id=DEFAULT_ORG_ID)
             return user
 
-    @enforce_types
-    @trace_method
-    def list_users(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticUser]:
-        """List all users with optional pagination."""
-        with db_registry.session() as session:
-            users = UserModel.list(
-                db_session=session,
-                after=after,
-                limit=limit,
-            )
-            return [user.to_pydantic() for user in users]
-
     @enforce_types
     @trace_method
     async def list_actors_async(self, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticUser]:

letta/settings.py

@@ -12,8 +12,6 @@ from letta.services.summarizer.enums import SummarizationMode
 
 
 class ToolSettings(BaseSettings):
-    composio_api_key: str | None = Field(default=None, description="API key for Composio")
-
     # Sandbox Configurations
     e2b_api_key: str | None = Field(default=None, description="API key for using E2B as a tool sandbox")
     e2b_sandbox_template_id: str | None = Field(default=None, description="Template ID for E2B Sandbox. Updated Manually.")
@@ -111,6 +109,14 @@ class ModelSettings(BaseSettings):
         validation_alias=AliasChoices("OPENAI_BASE_URL", "OPENAI_API_BASE"),  # pydantic-settings v1
     )
 
+    # openrouter
+    openrouter_api_key: Optional[str] = None
+    # Optional additional headers recommended by OpenRouter
+    # See https://openrouter.ai/docs/quick-start for details
+    openrouter_referer: Optional[str] = None  # e.g., your site URL
+    openrouter_title: Optional[str] = None  # e.g., your app name
+    openrouter_handle_base: Optional[str] = None
+
     # deepseek
     deepseek_api_key: Optional[str] = None
 
@@ -129,6 +135,16 @@ class ModelSettings(BaseSettings):
     # anthropic
     anthropic_api_key: Optional[str] = None
     anthropic_max_retries: int = 3
+    anthropic_sonnet_1m: bool = Field(
+        default=False,
+        description=(
+            "Enable 1M-token context window for Claude Sonnet 4/4.5. When true, adds the"
+            " 'context-1m-2025-08-07' beta to Anthropic requests and sets model context_window"
+            " to 1,000,000 instead of 200,000. Note: This feature is in beta and not available"
+            " to all orgs; once GA, this flag can be removed and behavior can default to on."
+        ),
+        alias="ANTHROPIC_SONNET_1M",
+    )
 
     # ollama
     ollama_base_url: Optional[str] = None
@@ -156,6 +172,7 @@ class ModelSettings(BaseSettings):
 
     # vLLM
     vllm_api_base: Optional[str] = None
+    vllm_handle_base: Optional[str] = None
 
     # lmstudio
     lmstudio_base_url: Optional[str] = None
@@ -232,7 +249,7 @@ class Settings(BaseSettings):
     pg_echo: bool = False  # Logging
     pool_pre_ping: bool = True  # Pre ping to check for dead connections
     pool_use_lifo: bool = True
-    disable_sqlalchemy_pooling: bool = False
+    disable_sqlalchemy_pooling: bool = True
     db_max_concurrent_sessions: Optional[int] = None
 
     redis_host: Optional[str] = Field(default=None, description="Host for Redis instance")
@@ -271,7 +288,6 @@ class Settings(BaseSettings):
     event_loop_threadpool_max_workers: int = 43
 
     # experimental toggle
-    use_experimental: bool = False
     use_vertex_structured_outputs_experimental: bool = False
     use_asyncio_shield: bool = True
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.7.dev20251006104136
+Version: 0.11.7.dev20251008104128
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License
@@ -14,12 +14,12 @@ Requires-Dist: black[jupyter]>=24.2.0
 Requires-Dist: brotli>=1.1.0
 Requires-Dist: certifi>=2025.6.15
 Requires-Dist: colorama>=0.4.6
-Requires-Dist: composio-core>=0.7.7
 Requires-Dist: datamodel-code-generator[http]>=0.25.0
 Requires-Dist: demjson3>=3.0.6
 Requires-Dist: docstring-parser<0.17,>=0.16
 Requires-Dist: exa-py>=1.15.4
 Requires-Dist: faker>=36.1.0
+Requires-Dist: google-genai>=1.15.0
 Requires-Dist: grpcio-tools>=1.68.1
 Requires-Dist: grpcio>=1.68.1
 Requires-Dist: html2text>=2020.1.16
@@ -109,8 +109,6 @@ Requires-Dist: langchain-community>=0.3.7; extra == 'external-tools'
 Requires-Dist: langchain>=0.3.7; extra == 'external-tools'
 Requires-Dist: turbopuffer>=0.5.17; extra == 'external-tools'
 Requires-Dist: wikipedia>=1.4.0; extra == 'external-tools'
-Provides-Extra: google
-Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: modal
 Requires-Dist: modal>=1.1.0; extra == 'modal'
 Provides-Extra: pinecone
@@ -417,7 +415,7 @@ agent_state = client.agents.create(
 
 # Or attach tools to an existing agent
 client.agents.tool.attach(
-    agent_id=agent_state.id,
+    agent_id=agent_state.id
     tool_id=tool.id
 )