letta-nightly 0.8.3.dev20250612104349__py3-none-any.whl → 0.8.4.dev20250613104250__py3-none-any.whl

letta/services/passage_manager.py

@@ -521,6 +521,7 @@ class PassageManager:
         agent_id: str,
         text: str,
         actor: PydanticUser,
+        image_ids: Optional[List[str]] = None,
     ) -> List[PydanticPassage]:
         """Insert passage(s) into archival memory"""
 

letta/services/source_manager.py

@@ -1,21 +1,10 @@
 import asyncio
-from datetime import datetime
 from typing import List, Optional
 
-from sqlalchemy import select, update
-from sqlalchemy.dialects.postgresql import insert as pg_insert
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.orm import selectinload
-
 from letta.orm.errors import NoResultFound
-from letta.orm.file import FileContent as FileContentModel
-from letta.orm.file import FileMetadata as FileMetadataModel
 from letta.orm.source import Source as SourceModel
-from letta.orm.sqlalchemy_base import AccessType
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState as PydanticAgentState
-from letta.schemas.enums import FileProcessingStatus
-from letta.schemas.file import FileMetadata as PydanticFileMetadata
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.source import SourceUpdate
 from letta.schemas.user import User as PydanticUser
@@ -148,200 +137,3 @@ class SourceManager:
                 return None
             else:
                 return sources[0].to_pydantic()
-
-    @enforce_types
-    @trace_method
-    async def create_file(
-        self,
-        file_metadata: PydanticFileMetadata,
-        actor: PydanticUser,
-        *,
-        text: Optional[str] = None,
-    ) -> PydanticFileMetadata:
-
-        # short-circuit if it already exists
-        existing = await self.get_file_by_id(file_metadata.id, actor=actor)
-        if existing:
-            return existing
-
-        async with db_registry.async_session() as session:
-            try:
-                file_metadata.organization_id = actor.organization_id
-                file_orm = FileMetadataModel(**file_metadata.model_dump(to_orm=True, exclude_none=True))
-                await file_orm.create_async(session, actor=actor, no_commit=True)
-
-                if text is not None:
-                    content_orm = FileContentModel(file_id=file_orm.id, text=text)
-                    await content_orm.create_async(session, actor=actor, no_commit=True)
-
-                await session.commit()
-                await session.refresh(file_orm)
-                return await file_orm.to_pydantic_async()
-
-            except IntegrityError:
-                await session.rollback()
-                return await self.get_file_by_id(file_metadata.id, actor=actor)
-
-    # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
-    @enforce_types
-    @trace_method
-    async def get_file_by_id(
-        self,
-        file_id: str,
-        actor: Optional[PydanticUser] = None,
-        *,
-        include_content: bool = False,
-    ) -> Optional[PydanticFileMetadata]:
-        """Retrieve a file by its ID.
-
-        If `include_content=True`, the FileContent relationship is eagerly
-        loaded so `to_pydantic(include_content=True)` never triggers a
-        lazy SELECT (avoids MissingGreenlet).
-        """
-        async with db_registry.async_session() as session:
-            try:
-                if include_content:
-                    # explicit eager load
-                    query = (
-                        select(FileMetadataModel).where(FileMetadataModel.id == file_id).options(selectinload(FileMetadataModel.content))
-                    )
-                    # apply org-scoping if actor provided
-                    if actor:
-                        query = FileMetadataModel.apply_access_predicate(
-                            query,
-                            actor,
-                            access=["read"],
-                            access_type=AccessType.ORGANIZATION,
-                        )
-
-                    result = await session.execute(query)
-                    file_orm = result.scalar_one()
-                else:
-                    # fast path (metadata only)
-                    file_orm = await FileMetadataModel.read_async(
-                        db_session=session,
-                        identifier=file_id,
-                        actor=actor,
-                    )
-
-                return await file_orm.to_pydantic_async(include_content=include_content)
-
-            except NoResultFound:
-                return None
-
-    @enforce_types
-    @trace_method
-    async def update_file_status(
-        self,
-        *,
-        file_id: str,
-        actor: PydanticUser,
-        processing_status: Optional[FileProcessingStatus] = None,
-        error_message: Optional[str] = None,
-    ) -> PydanticFileMetadata:
-        """
-        Update processing_status and/or error_message on a FileMetadata row.
-
-        * 1st round-trip → UPDATE
-        * 2nd round-trip → SELECT fresh row (same as read_async)
-        """
-
-        if processing_status is None and error_message is None:
-            raise ValueError("Nothing to update")
-
-        values: dict[str, object] = {"updated_at": datetime.utcnow()}
-        if processing_status is not None:
-            values["processing_status"] = processing_status
-        if error_message is not None:
-            values["error_message"] = error_message
-
-        async with db_registry.async_session() as session:
-            # Fast in-place update – no ORM hydration
-            stmt = (
-                update(FileMetadataModel)
-                .where(
-                    FileMetadataModel.id == file_id,
-                    FileMetadataModel.organization_id == actor.organization_id,
-                )
-                .values(**values)
-            )
-            await session.execute(stmt)
-            await session.commit()
-
-            # Reload via normal accessor so we return a fully-attached object
-            file_orm = await FileMetadataModel.read_async(
-                db_session=session,
-                identifier=file_id,
-                actor=actor,
-            )
-            return await file_orm.to_pydantic_async()
-
-    @enforce_types
-    @trace_method
-    async def upsert_file_content(
-        self,
-        *,
-        file_id: str,
-        text: str,
-        actor: PydanticUser,
-    ) -> PydanticFileMetadata:
-        async with db_registry.async_session() as session:
-            await FileMetadataModel.read_async(session, file_id, actor)
-
-            dialect_name = session.bind.dialect.name
-
-            if dialect_name == "postgresql":
-                stmt = (
-                    pg_insert(FileContentModel)
-                    .values(file_id=file_id, text=text)
-                    .on_conflict_do_update(
-                        index_elements=[FileContentModel.file_id],
-                        set_={"text": text},
-                    )
-                )
-                await session.execute(stmt)
-            else:
-                # Emulate upsert for SQLite and others
-                stmt = select(FileContentModel).where(FileContentModel.file_id == file_id)
-                result = await session.execute(stmt)
-                existing = result.scalar_one_or_none()
-
-                if existing:
-                    await session.execute(update(FileContentModel).where(FileContentModel.file_id == file_id).values(text=text))
-                else:
-                    session.add(FileContentModel(file_id=file_id, text=text))
-
-            await session.commit()
-
-            # Reload with content
-            query = select(FileMetadataModel).options(selectinload(FileMetadataModel.content)).where(FileMetadataModel.id == file_id)
-            result = await session.execute(query)
-            return await result.scalar_one().to_pydantic_async(include_content=True)
-
-    @enforce_types
-    @trace_method
-    async def list_files(
-        self, source_id: str, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, include_content: bool = False
-    ) -> List[PydanticFileMetadata]:
-        """List all files with optional pagination."""
-        async with db_registry.async_session() as session:
-            options = [selectinload(FileMetadataModel.content)] if include_content else None
-
-            files = await FileMetadataModel.list_async(
-                db_session=session,
-                after=after,
-                limit=limit,
-                organization_id=actor.organization_id,
-                source_id=source_id,
-                query_options=options,
-            )
-            return [await file.to_pydantic_async(include_content=include_content) for file in files]
-
-    @enforce_types
-    @trace_method
-    async def delete_file(self, file_id: str, actor: PydanticUser) -> PydanticFileMetadata:
-        """Delete a file by its ID."""
-        async with db_registry.async_session() as session:
-            file = await FileMetadataModel.read_async(db_session=session, identifier=file_id)
-            await file.hard_delete_async(db_session=session, actor=actor)
-            return await file.to_pydantic_async()

letta/services/tool_executor/composio_tool_executor.py

@@ -26,7 +26,11 @@ class ExternalComposioToolExecutor(ToolExecutor):
         sandbox_config: Optional[SandboxConfig] = None,
         sandbox_env_vars: Optional[Dict[str, Any]] = None,
     ) -> ToolExecutionResult:
-        assert agent_state is not None, "Agent state is required for external Composio tools"
+        if agent_state is None:
+            return ToolExecutionResult(
+                status="error",
+                func_return="Agent state is required for external Composio tools. Please contact Letta support if you see this error.",
+            )
         action_name = generate_composio_action_from_func_name(tool.name)
 
         # Get entity ID from the agent_state

letta/services/tool_executor/files_tool_executor.py

@@ -1,12 +1,17 @@
+import asyncio
+import re
 from typing import Any, Dict, List, Optional, Tuple
 
+from letta.log import get_logger
 from letta.schemas.agent import AgentState
+from letta.schemas.file import FileMetadata
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.file_manager import FileManager
 from letta.services.file_processor.chunker.line_chunker import LineChunker
 from letta.services.files_agents_manager import FileAgentManager
 from letta.services.message_manager import MessageManager
@@ -19,6 +24,15 @@ from letta.utils import get_friendly_error_msg
 class LettaFileToolExecutor(ToolExecutor):
     """Executor for Letta file tools with direct implementation of functions."""
 
+    # Production safety constants
+    MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024  # 50MB limit per file
+    MAX_TOTAL_CONTENT_SIZE = 200 * 1024 * 1024  # 200MB total across all files
+    MAX_REGEX_COMPLEXITY = 1000  # Prevent catastrophic backtracking
+    MAX_MATCHES_PER_FILE = 20  # Limit matches per file
+    MAX_TOTAL_MATCHES = 50  # Global match limit
+    GREP_TIMEOUT_SECONDS = 30  # Max time for grep operation
+    MAX_CONTEXT_LINES = 1  # Lines of context around matches
+
     def __init__(
         self,
         message_manager: MessageManager,
@@ -37,7 +51,9 @@ class LettaFileToolExecutor(ToolExecutor):
 
         # TODO: This should be passed in to for testing purposes
         self.files_agents_manager = FileAgentManager()
+        self.file_manager = FileManager()
         self.source_manager = SourceManager()
+        self.logger = get_logger(__name__)
 
     async def execute(
         self,
@@ -99,12 +115,12 @@ class LettaFileToolExecutor(ToolExecutor):
             )
 
         file_id = file_agent.file_id
-        file = await self.source_manager.get_file_by_id(file_id=file_id, actor=self.actor, include_content=True)
+        file = await self.file_manager.get_file_by_id(file_id=file_id, actor=self.actor, include_content=True)
 
         # TODO: Inefficient, maybe we can pre-compute this
         # TODO: This is also not the best way to split things - would be cool to have "content aware" splitting
         # TODO: Split code differently from large text blurbs
-        content_lines = LineChunker().chunk_text(text=file.content, start=start, end=end)
+        content_lines = LineChunker().chunk_text(text=file.content, file_metadata=file, start=start, end=end)
         visible_content = "\n".join(content_lines)
 
         await self.files_agents_manager.update_file_agent_by_id(
@@ -120,19 +136,279 @@ class LettaFileToolExecutor(ToolExecutor):
         )
         return "Success"
 
-    async def grep(self, agent_state: AgentState, pattern: str) -> str:
-        """Stub for grep tool."""
-        raise NotImplementedError
+    def _validate_regex_pattern(self, pattern: str) -> None:
+        """Validate regex pattern to prevent catastrophic backtracking."""
+        if len(pattern) > self.MAX_REGEX_COMPLEXITY:
+            raise ValueError(f"Pattern too complex: {len(pattern)} chars > {self.MAX_REGEX_COMPLEXITY} limit")
+
+        # Test compile the pattern to catch syntax errors early
+        try:
+            re.compile(pattern, re.IGNORECASE | re.MULTILINE)
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern: {e}")
+
+    def _get_context_lines(self, text: str, file_metadata: FileMetadata, match_line_idx: int, total_lines: int) -> List[str]:
+        """Get context lines around a match using LineChunker."""
+        start_idx = max(0, match_line_idx - self.MAX_CONTEXT_LINES)
+        end_idx = min(total_lines, match_line_idx + self.MAX_CONTEXT_LINES + 1)
+
+        # Use LineChunker to get formatted lines with numbers
+        chunker = LineChunker()
+        context_lines = chunker.chunk_text(text, file_metadata=file_metadata, start=start_idx, end=end_idx, add_metadata=False)
+
+        # Add match indicator
+        formatted_lines = []
+        for line in context_lines:
+            if line and ":" in line:
+                line_num_str = line.split(":")[0].strip()
+                try:
+                    line_num = int(line_num_str)
+                    prefix = ">" if line_num == match_line_idx + 1 else " "
+                    formatted_lines.append(f"{prefix} {line}")
+                except ValueError:
+                    formatted_lines.append(f"  {line}")
+            else:
+                formatted_lines.append(f"  {line}")
+
+        return formatted_lines
+
+    async def grep(self, agent_state: AgentState, pattern: str, include: Optional[str] = None) -> str:
+        """
+        Search for pattern in all attached files and return matches with context.
+
+        Args:
+            agent_state: Current agent state
+            pattern: Regular expression pattern to search for
+            include: Optional pattern to filter filenames to include in the search
+
+        Returns:
+            Formatted string with search results, file names, line numbers, and context
+        """
+        if not pattern or not pattern.strip():
+            raise ValueError("Empty search pattern provided")
+
+        pattern = pattern.strip()
+        self._validate_regex_pattern(pattern)
+
+        # Validate include pattern if provided
+        include_regex = None
+        if include and include.strip():
+            include = include.strip()
+            # Convert glob pattern to regex if it looks like a glob pattern
+            if "*" in include and not any(c in include for c in ["^", "$", "(", ")", "[", "]", "{", "}", "\\", "+"]):
+                # Simple glob to regex conversion
+                include_pattern = include.replace(".", r"\.").replace("*", ".*").replace("?", ".")
+                if not include_pattern.endswith("$"):
+                    include_pattern += "$"
+            else:
+                include_pattern = include
+
+            self._validate_regex_pattern(include_pattern)
+            include_regex = re.compile(include_pattern, re.IGNORECASE)
+
+        # Get all attached files for this agent
+        file_agents = await self.files_agents_manager.list_files_for_agent(agent_id=agent_state.id, actor=self.actor)
+
+        if not file_agents:
+            return "No files are currently attached to search"
+
+        # Filter files by filename pattern if include is specified
+        if include_regex:
+            original_count = len(file_agents)
+            file_agents = [fa for fa in file_agents if include_regex.search(fa.file_name)]
+            if not file_agents:
+                return f"No files match the filename pattern '{include}' (filtered {original_count} files)"
+
+        # Compile regex pattern with appropriate flags
+        regex_flags = re.MULTILINE
+        regex_flags |= re.IGNORECASE
+
+        pattern_regex = re.compile(pattern, regex_flags)
+
+        results = []
+        total_matches = 0
+        total_content_size = 0
+        files_processed = 0
+        files_skipped = 0
+
+        # Use asyncio timeout to prevent hanging
+        async def _search_files():
+            nonlocal results, total_matches, total_content_size, files_processed, files_skipped
+
+            for file_agent in file_agents:
+                # Load file content
+                file = await self.file_manager.get_file_by_id(file_id=file_agent.file_id, actor=self.actor, include_content=True)
+
+                if not file or not file.content:
+                    files_skipped += 1
+                    self.logger.warning(f"Grep: Skipping file {file_agent.file_name} - no content available")
+                    continue
+
+                # Check individual file size
+                content_size = len(file.content.encode("utf-8"))
+                if content_size > self.MAX_FILE_SIZE_BYTES:
+                    files_skipped += 1
+                    self.logger.warning(
+                        f"Grep: Skipping file {file.file_name} - too large ({content_size:,} bytes > {self.MAX_FILE_SIZE_BYTES:,} limit)"
+                    )
+                    results.append(f"[SKIPPED] {file.file_name}: File too large ({content_size:,} bytes)")
+                    continue
+
+                # Check total content size across all files
+                total_content_size += content_size
+                if total_content_size > self.MAX_TOTAL_CONTENT_SIZE:
+                    files_skipped += 1
+                    self.logger.warning(
+                        f"Grep: Skipping file {file.file_name} - total content size limit exceeded ({total_content_size:,} bytes > {self.MAX_TOTAL_CONTENT_SIZE:,} limit)"
+                    )
+                    results.append(f"[SKIPPED] {file.file_name}: Total content size limit exceeded")
+                    break
+
+                files_processed += 1
+                file_matches = 0
+
+                # Use LineChunker to get all lines with proper formatting
+                chunker = LineChunker()
+                formatted_lines = chunker.chunk_text(file.content, file_metadata=file)
+
+                # Remove metadata header
+                if formatted_lines and formatted_lines[0].startswith("[Viewing"):
+                    formatted_lines = formatted_lines[1:]
+
+                # Search for matches in formatted lines
+                for formatted_line in formatted_lines:
+                    if total_matches >= self.MAX_TOTAL_MATCHES:
+                        results.append(f"[TRUNCATED] Maximum total matches ({self.MAX_TOTAL_MATCHES}) reached")
+                        return
+
+                    if file_matches >= self.MAX_MATCHES_PER_FILE:
+                        results.append(f"[TRUNCATED] {file.file_name}: Maximum matches per file ({self.MAX_MATCHES_PER_FILE}) reached")
+                        break
+
+                    # Extract line number and content from formatted line
+                    if ":" in formatted_line:
+                        try:
+                            line_parts = formatted_line.split(":", 1)
+                            line_num = int(line_parts[0].strip())
+                            line_content = line_parts[1].strip() if len(line_parts) > 1 else ""
+                        except (ValueError, IndexError):
+                            continue
 
-    # TODO: Make this paginated?
-    async def search_files(self, agent_state: AgentState, query: str) -> List[str]:
-        """Search for text within attached files and return passages with their source filenames."""
+                        if pattern_regex.search(line_content):
+                            # Get context around the match (convert back to 0-based indexing)
+                            context_lines = self._get_context_lines(file.content, file, line_num - 1, len(file.content.splitlines()))
+
+                            # Format the match result
+                            match_header = f"\n=== {file.file_name}:{line_num} ==="
+                            match_content = "\n".join(context_lines)
+                            results.append(f"{match_header}\n{match_content}")
+
+                            file_matches += 1
+                            total_matches += 1
+
+                # Break if global limits reached
+                if total_matches >= self.MAX_TOTAL_MATCHES:
+                    break
+
+        # Execute with timeout
+        await asyncio.wait_for(_search_files(), timeout=self.GREP_TIMEOUT_SECONDS)
+
+        # Format final results
+        if not results or total_matches == 0:
+            summary = f"No matches found for pattern: '{pattern}'"
+            if include:
+                summary += f" in files matching '{include}'"
+            if files_skipped > 0:
+                summary += f" (searched {files_processed} files, skipped {files_skipped})"
+            return summary
+
+        # Add summary header
+        summary_parts = [f"Found {total_matches} matches"]
+        if files_processed > 0:
+            summary_parts.append(f"in {files_processed} files")
+        if files_skipped > 0:
+            summary_parts.append(f"({files_skipped} files skipped)")
+
+        summary = " ".join(summary_parts) + f" for pattern: '{pattern}'"
+        if include:
+            summary += f" in files matching '{include}'"
+
+        # Combine all results
+        formatted_results = [summary, "=" * len(summary)] + results
+
+        return "\n".join(formatted_results)
+
+    async def search_files(self, agent_state: AgentState, query: str, limit: int = 10) -> str:
+        """
+        Search for text within attached files using semantic search and return passages with their source filenames.
+
+        Args:
+            agent_state: Current agent state
+            query: Search query for semantic matching
+            limit: Maximum number of results to return (default: 10)
+
+        Returns:
+            Formatted string with search results in IDE/terminal style
+        """
+        if not query or not query.strip():
+            raise ValueError("Empty search query provided")
+
+        query = query.strip()
+
+        # Apply reasonable limit
+        limit = min(limit, self.MAX_TOTAL_MATCHES)
+
+        self.logger.info(f"Semantic search started for agent {agent_state.id} with query '{query}' (limit: {limit})")
+
+        # Get semantic search results
         passages = await self.agent_manager.list_source_passages_async(actor=self.actor, agent_id=agent_state.id, query_text=query)
-        formatted_results = []
+
+        if not passages:
+            return f"No semantic matches found for query: '{query}'"
+
+        # Limit results
+        passages = passages[:limit]
+
+        # Group passages by file for better organization
+        files_with_passages = {}
         for p in passages:
-            if p.file_name:
-                formatted_result = f"[{p.file_name}]:\n{p.text}"
-            else:
-                formatted_result = p.text
-            formatted_results.append(formatted_result)
-        return formatted_results
+            file_name = p.file_name if p.file_name else "Unknown File"
+            if file_name not in files_with_passages:
+                files_with_passages[file_name] = []
+            files_with_passages[file_name].append(p)
+
+        results = []
+        total_passages = 0
+
+        for file_name, file_passages in files_with_passages.items():
+            for passage in file_passages:
+                total_passages += 1
+
+                # Format each passage with terminal-style header
+                passage_header = f"\n=== {file_name} (passage #{total_passages}) ==="
+
+                # Format the passage text with some basic formatting
+                passage_text = passage.text.strip()
+
+                # Format the passage text without line numbers
+                lines = passage_text.splitlines()
+                formatted_lines = []
+                for line in lines[:20]:  # Limit to first 20 lines per passage
+                    formatted_lines.append(f"  {line}")
+
+                if len(lines) > 20:
+                    formatted_lines.append(f"  ... [truncated {len(lines) - 20} more lines]")
+
+                passage_content = "\n".join(formatted_lines)
+                results.append(f"{passage_header}\n{passage_content}")
+
+        # Create summary header
+        file_count = len(files_with_passages)
+        summary = f"Found {total_passages} semantic matches in {file_count} file{'s' if file_count != 1 else ''} for query: '{query}'"
+
+        # Combine all results
+        formatted_results = [summary, "=" * len(summary)] + results
+
+        self.logger.info(f"Semantic search completed: {total_passages} matches across {file_count} files")
+
+        return "\n".join(formatted_results)

letta/services/user_manager.py

@@ -2,6 +2,7 @@ from typing import List, Optional
 
 from sqlalchemy import select, text
 
+from letta.constants import DEFAULT_ORG_ID
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
@@ -9,7 +10,6 @@ from letta.otel.tracing import trace_method
 from letta.schemas.user import User as PydanticUser
 from letta.schemas.user import UserUpdate
 from letta.server.db import db_registry
-from letta.services.organization_manager import OrganizationManager
 from letta.utils import enforce_types
 from letta.settings import settings
 
@@ -22,7 +22,7 @@ class UserManager:
 
     @enforce_types
     @trace_method
-    def create_default_user(self, org_id: str = OrganizationManager.DEFAULT_ORG_ID) -> PydanticUser:
+    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
@@ -43,7 +43,7 @@ class UserManager:
 
     @enforce_types
     @trace_method
-    async def create_default_actor_async(self, org_id: str = OrganizationManager.DEFAULT_ORG_ID) -> PydanticUser:
+    async def create_default_actor_async(self, org_id: str = DEFAULT_ORG_ID) -> PydanticUser:
         """Create the default user."""
         async with db_registry.async_session() as session:
             # Make sure the org id exists
@@ -191,19 +191,19 @@ class UserManager:
         try:
             return await self.get_actor_by_id_async(self.DEFAULT_USER_ID)
         except NoResultFound:
-            return await self.create_default_actor_async(org_id=self.DEFAULT_ORG_ID)
+            return await self.create_default_actor_async(org_id=DEFAULT_ORG_ID)
 
     @enforce_types
     @trace_method
     async def get_actor_or_default_async(self, actor_id: Optional[str] = None):
         """Fetch the user or default user asynchronously."""
-        if not actor_id:
-            return await self.get_default_actor_async()
+        target_id = actor_id or self.DEFAULT_USER_ID
 
         try:
-            return await self.get_actor_by_id_async(actor_id=actor_id)
+            return await self.get_actor_by_id_async(target_id)
         except NoResultFound:
-            return await self.get_default_actor_async()
+            user = await self.create_default_actor_async(org_id=DEFAULT_ORG_ID)
+            return user
 
     @enforce_types
     @trace_method

letta/system.py

@@ -218,11 +218,13 @@ def get_token_limit_warning():
     return json_dumps(packaged_message)
 
 
-def unpack_message(packed_message) -> str:
+def unpack_message(packed_message: str) -> str:
     """Take a packed message string and attempt to extract the inner message content"""
 
     try:
         message_json = json.loads(packed_message)
+        if type(message_json) is not dict:
+            return packed_message
     except:
         return packed_message