letta-nightly 0.13.0.dev20251031104146__py3-none-any.whl → 0.13.1.dev20251101010313__py3-none-any.whl

letta/services/summarizer/summarizer.py

@@ -4,7 +4,13 @@ import traceback
 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, MESSAGE_SUMMARY_REQUEST_ACK
+from letta.constants import (
+    DEFAULT_MESSAGE_TOOL,
+    DEFAULT_MESSAGE_TOOL_KWARG,
+    MESSAGE_SUMMARY_REQUEST_ACK,
+    TOOL_RETURN_TRUNCATION_CHARS,
+)
+from letta.errors import ContextWindowExceededError
 from letta.helpers.message_helper import convert_message_creates_to_messages
 from letta.llm_api.llm_client import LLMClient
 from letta.log import get_logger
@@ -394,7 +400,27 @@ async def simple_summary(messages: List[Message], llm_config: LLMConfig, actor:
         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)
+        try:
+            raise llm_client.handle_llm_error(e)
+        except ContextWindowExceededError as context_error:
+            logger.warning(
+                f"Context window exceeded during summarization, falling back to truncated tool returns. Original error: {context_error}"
+            )
+
+            # Fallback: rebuild request with truncated tool returns
+            request_data = llm_client.build_request_data(
+                AgentType.letta_v1_agent,
+                input_messages_obj,
+                summarizer_llm_config,
+                tools=[],
+                tool_return_truncation_chars=TOOL_RETURN_TRUNCATION_CHARS,
+            )
+
+            try:
+                response_data = await llm_client.request_async(request_data, summarizer_llm_config)
+            except Exception as fallback_error:
+                logger.error(f"Fallback summarization also failed: {fallback_error}")
+                raise llm_client.handle_llm_error(fallback_error)
     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")

letta/services/tool_executor/builtin_tool_executor.py

@@ -189,7 +189,7 @@ class LettaBuiltinToolExecutor(ToolExecutor):
             return json.dumps(response, indent=2, ensure_ascii=False)
 
         except Exception as e:
-            logger.error(f"Exa search failed for query '{query}': {str(e)}")
+            logger.info(f"Exa search failed for query '{query}': {str(e)}")
             return json.dumps({"query": query, "error": f"Search failed: {str(e)}"})
 
     async def fetch_webpage(self, agent_state: "AgentState", url: str) -> str:

letta/services/tool_executor/core_tool_executor.py

@@ -688,115 +688,6 @@ class LettaCoreToolExecutor(ToolExecutor):
         except Exception as e:
             raise Exception(f"Error performing rename: {str(e)}")
 
-    async def memory_view(self, agent_state: AgentState, actor: User, path: str, view_range: Optional[int] = None) -> str:
-        """View the content of a memory block with optional line range."""
-        try:
-            # Special case: if path is "/memories", list all blocks
-            if path == "/memories":
-                blocks = agent_state.memory.get_blocks()
-
-                if not blocks:
-                    raise ValueError("No memory blocks found.")
-
-                result_lines = [f"Found {len(blocks)} memory block(s):\n"]
-
-                for i, block in enumerate(blocks, 1):
-                    content = str(block.value)
-                    content_length = len(content)
-                    line_count = len(content.split("\n")) if content else 0
-
-                    # Basic info
-                    block_info = [f"{i}. {block.label}"]
-
-                    # Add description if available
-                    if block.description:
-                        block_info.append(f"   Description: {block.description}")
-
-                    # Add read-only status
-                    if block.read_only:
-                        block_info.append("   Read-only: true")
-
-                    # Add content stats
-                    block_info.append(f"   Character limit: {block.limit}")
-                    block_info.append(f"   Current length: {content_length} characters")
-                    block_info.append(f"   Lines: {line_count}")
-
-                    # Add content preview (first 100 characters)
-                    if content:
-                        preview = content[:100].replace("\n", "\\n")
-                        if len(content) > 100:
-                            preview += "..."
-                        block_info.append(f"   Preview: {preview}")
-                    else:
-                        block_info.append("   Preview: (empty)")
-
-                    result_lines.append("\n".join(block_info))
-                    if i < len(blocks):  # Add separator between blocks
-                        result_lines.append("")
-
-                return "\n".join(result_lines)
-
-            # Extract memory block label from path (e.g., "/memories/preferences.txt" -> "preferences.txt")
-            if path.startswith("/memories/"):
-                label = path[10:]  # Remove "/memories/" prefix
-            else:
-                label = path
-
-            # Get the memory block
-            memory_block = agent_state.memory.get_block(label)
-            if memory_block is None:
-                raise ValueError(f"Error: Memory block '{label}' does not exist")
-
-            # Get the content
-            content = str(memory_block.value)
-            if not content:
-                raise ValueError(f"Memory block '{label}' is empty")
-
-            # Split content into lines
-            lines = content.split("\n")
-            total_lines = len(lines)
-
-            # Handle view_range parameter
-            if view_range is not None:
-                if view_range <= 0:
-                    raise ValueError(f"Error: view_range must be positive, got {view_range}")
-
-                # Show only the first view_range lines
-                lines_to_show = lines[:view_range]
-                range_info = f" (showing first {view_range} of {total_lines} lines)"
-            else:
-                lines_to_show = lines
-                range_info = f" ({total_lines} lines total)"
-
-            # Format output with line numbers
-            numbered_lines = []
-            for i, line in enumerate(lines_to_show, start=1):
-                numbered_lines.append(f"Line {i}: {line}")
-
-            numbered_content = "\n".join(numbered_lines)
-
-            # Add metadata information
-            metadata_info = []
-            if memory_block.description:
-                metadata_info.append(f"Description: {memory_block.description}")
-            if memory_block.read_only:
-                metadata_info.append("Read-only: true")
-            metadata_info.append(f"Character limit: {memory_block.limit}")
-            metadata_info.append(f"Current length: {len(content)} characters")
-
-            metadata_str = "\n".join(metadata_info)
-
-            result = f"Memory block: {label}{range_info}\n"
-            result += f"Metadata:\n{metadata_str}\n\n"
-            result += f"Content:\n{numbered_content}"
-
-            return result
-
-        except KeyError:
-            raise ValueError(f"Error: Memory block '{label}' does not exist")
-        except Exception as e:
-            raise Exception(f"Error viewing memory block: {str(e)}")
-
     async def memory_create(
         self, agent_state: AgentState, actor: User, path: str, description: str, file_text: Optional[str] = None
     ) -> str:
@@ -961,14 +852,8 @@ class LettaCoreToolExecutor(ToolExecutor):
         insert_text: Optional[str] = None,
         old_path: Optional[str] = None,
         new_path: Optional[str] = None,
-        view_range: Optional[int] = None,
     ) -> Optional[str]:
-        if command == "view":
-            if path is None:
-                raise ValueError("Error: path is required for view command")
-            return await self.memory_view(agent_state, actor, path, view_range)
-
-        elif command == "create":
+        if command == "create":
             if path is None:
                 raise ValueError("Error: path is required for create command")
             if description is None:
@@ -1007,4 +892,4 @@ class LettaCoreToolExecutor(ToolExecutor):
                 )
 
         else:
-            raise ValueError(f"Error: Unknown command '{command}'. Supported commands: str_replace, str_insert, insert, delete, rename")
+            raise ValueError(f"Error: Unknown command '{command}'. Supported commands: create, str_replace, insert, delete, rename")

letta/services/tool_sandbox/e2b_sandbox.py

@@ -102,7 +102,10 @@ 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}")
+                logger.info(
+                    f"E2B execution failed for ID {e2b_sandbox.sandbox_id}: {self.tool_name} - {execution.error.name}: {execution.error.value}"
+                )
+                logger.info(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
                 log_event(
                     "e2b_execution_failed",
                     {

letta/services/tool_schema_generator.py

@@ -45,7 +45,7 @@ def generate_schema_for_tool_creation(
 
             return derive_typescript_json_schema(source_code=tool.source_code)
         except Exception as e:
-            logger.error(f"Failed to derive TypeScript json schema: {e}")
+            logger.warning(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)
@@ -65,7 +65,7 @@ def generate_schema_for_tool_creation(
             try:
                 return derive_openai_json_schema(source_code=tool.source_code)
             except Exception as e:
-                logger.error(f"Failed to derive json schema: {e}")
+                logger.warning(f"Failed to derive json schema: {e}")
                 raise ValueError(f"Failed to derive json schema: {e}")
     else:
         # TODO: convert to explicit error

letta/validators.py

@@ -63,6 +63,27 @@ SandboxConfigId = Annotated[str, PATH_VALIDATORS[PrimitiveType.SANDBOX_CONFIG.va
 StepId = Annotated[str, PATH_VALIDATORS[PrimitiveType.STEP.value]()]
 IdentityId = Annotated[str, PATH_VALIDATORS[PrimitiveType.IDENTITY.value]()]
 
+# Infrastructure types
+McpServerId = Annotated[str, PATH_VALIDATORS[PrimitiveType.MCP_SERVER.value]()]
+McpOAuthId = Annotated[str, PATH_VALIDATORS[PrimitiveType.MCP_OAUTH.value]()]
+FileAgentId = Annotated[str, PATH_VALIDATORS[PrimitiveType.FILE_AGENT.value]()]
+
+# Configuration types
+SandboxEnvId = Annotated[str, PATH_VALIDATORS[PrimitiveType.SANDBOX_ENV.value]()]
+AgentEnvId = Annotated[str, PATH_VALIDATORS[PrimitiveType.AGENT_ENV.value]()]
+
+# Core entity types
+UserId = Annotated[str, PATH_VALIDATORS[PrimitiveType.USER.value]()]
+OrganizationId = Annotated[str, PATH_VALIDATORS[PrimitiveType.ORGANIZATION.value]()]
+ToolRuleId = Annotated[str, PATH_VALIDATORS[PrimitiveType.TOOL_RULE.value]()]
+
+# Batch processing types
+BatchItemId = Annotated[str, PATH_VALIDATORS[PrimitiveType.BATCH_ITEM.value]()]
+BatchRequestId = Annotated[str, PATH_VALIDATORS[PrimitiveType.BATCH_REQUEST.value]()]
+
+# Telemetry types
+ProviderTraceId = Annotated[str, PATH_VALIDATORS[PrimitiveType.PROVIDER_TRACE.value]()]
+
 
 def raise_on_invalid_id(param_name: str, expected_prefix: PrimitiveType):
     """

{letta_nightly-0.13.0.dev20251031104146.dist-info → letta_nightly-0.13.1.dev20251101010313.dist-info}/METADATA

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