letta-nightly 0.8.7.dev20250628104142__tar.gz → 0.8.8.dev20250629225711__tar.gz

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.7.dev20250628104142
+Version: 0.8.8.dev20250629225711
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/__init__.py

@@ -1,6 +1,6 @@
 import os
 
-__version__ = "0.8.7"
+__version__ = "0.8.8"
 
 
 if os.environ.get("LETTA_VERSION"):

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/agents/helpers.py

@@ -210,17 +210,21 @@ def generate_step_id():
     return f"step-{uuid.uuid4()}"
 
 
-def _safe_load_dict(raw: str) -> dict:
+def _safe_load_tool_call_str(tool_call_args_str: str) -> dict:
     """Lenient JSON → dict with fallback to eval on assertion failure."""
-    if "}{" in raw:  # strip accidental parallel calls
-        raw = raw.split("}{", 1)[0] + "}"
+    # Temp hack to gracefully handle parallel tool calling attempt, only take first one
+    if "}{" in tool_call_args_str:
+        tool_call_args_str = tool_call_args_str.split("}{", 1)[0] + "}"
+
     try:
-        data = json.loads(raw)
-        if not isinstance(data, dict):
-            raise AssertionError
-        return data
-    except (json.JSONDecodeError, AssertionError):
-        return json.loads(raw) if raw else {}
+        tool_args = json.loads(tool_call_args_str)
+        if not isinstance(tool_args, dict):
+            # Load it again - this is due to sometimes Anthropic returning weird json @caren
+            tool_args = json.loads(tool_args)
+    except json.JSONDecodeError:
+        tool_args = {}
+
+    return tool_args
 
 
 def _pop_heartbeat(tool_args: dict) -> bool:

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/agents/letta_agent.py

@@ -15,7 +15,7 @@ from letta.agents.helpers import (
     _create_letta_response,
     _pop_heartbeat,
     _prepare_in_context_messages_no_persist_async,
-    _safe_load_dict,
+    _safe_load_tool_call_str,
     generate_step_id,
 )
 from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX
@@ -944,7 +944,7 @@ class LettaAgent(BaseAgent):
         # 1.  Parse and validate the tool-call envelope
         tool_call_name: str = tool_call.function.name
         tool_call_id: str = tool_call.id or f"call_{uuid.uuid4().hex[:8]}"
-        tool_args = _safe_load_dict(tool_call.function.arguments)
+        tool_args = _safe_load_tool_call_str(tool_call.function.arguments)
         request_heartbeat: bool = _pop_heartbeat(tool_args)
         tool_args.pop(INNER_THOUGHTS_KWARG, None)
 
@@ -993,6 +993,7 @@ class LettaAgent(BaseAgent):
 
         # 4.  Decide whether to keep stepping  (<<< focal section simplified)
         continue_stepping, heartbeat_reason, stop_reason = self._decide_continuation(
+            agent_state=agent_state,
             request_heartbeat=request_heartbeat,
             tool_call_name=tool_call_name,
             tool_rule_violated=tool_rule_violated,
@@ -1048,6 +1049,7 @@ class LettaAgent(BaseAgent):
 
     def _decide_continuation(
         self,
+        agent_state: AgentState,
         request_heartbeat: bool,
         tool_call_name: str,
         tool_rule_violated: bool,
@@ -1083,10 +1085,12 @@ class LettaAgent(BaseAgent):
             continue_stepping = False
             stop_reason = LettaStopReason(stop_reason=StopReasonType.max_steps.value)
         else:
-            uncalled = tool_rules_solver.get_uncalled_required_tools()
+            uncalled = tool_rules_solver.get_uncalled_required_tools(available_tools=set([t.name for t in agent_state.tools]))
             if not continue_stepping and uncalled:
                 continue_stepping = True
-                heartbeat_reason = f"{NON_USER_MSG_PREFIX}Missing required tools: " f"{', '.join(uncalled)}"
+                heartbeat_reason = (
+                    f"{NON_USER_MSG_PREFIX}Continuing, user expects these tools: [" f"{', '.join(uncalled)}] to be called still."
+                )
 
                 stop_reason = None  # reset – we’re still going
 

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/helpers/tool_rule_solver.py

@@ -151,11 +151,11 @@ class ToolRulesSolver(BaseModel):
         """Check if the tool is defined as a continue tool in the tool rules."""
         return any(rule.tool_name == tool_name for rule in self.continue_tool_rules)
 
-    def has_required_tools_been_called(self) -> bool:
+    def has_required_tools_been_called(self, available_tools: Set[str]) -> bool:
         """Check if all required-before-exit tools have been called."""
-        return len(self.get_uncalled_required_tools()) == 0
+        return len(self.get_uncalled_required_tools(available_tools=available_tools)) == 0
 
-    def get_uncalled_required_tools(self) -> List[str]:
+    def get_uncalled_required_tools(self, available_tools: Set[str]) -> List[str]:
         """Get the list of required-before-exit tools that have not been called yet."""
         if not self.required_before_exit_tool_rules:
             return []  # No required tools means no uncalled tools
@@ -163,7 +163,8 @@ class ToolRulesSolver(BaseModel):
         required_tool_names = {rule.tool_name for rule in self.required_before_exit_tool_rules}
         called_tool_names = set(self.tool_call_history)
 
-        return list(required_tool_names - called_tool_names)
+        # Get required tools that are uncalled AND available
+        return list((required_tool_names & available_tools) - called_tool_names)
 
     def get_ending_tool_names(self) -> List[str]:
         """Get the names of tools that are required before exit."""

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/orm/sqlalchemy_base.py

@@ -243,6 +243,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             join_conditions=join_conditions,
             identifier_keys=identifier_keys,
             identity_id=identity_id,
+            has_feedback=has_feedback,
             **kwargs,
         )
         if query_options:

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/services/agent_manager.py

@@ -779,6 +779,7 @@ class AgentManager:
                 "response_format": agent_update.response_format,
                 "last_run_completion": agent_update.last_run_completion,
                 "last_run_duration_ms": agent_update.last_run_duration_ms,
+                "timezone": agent_update.timezone,
             }
             for col, val in scalar_updates.items():
                 if val is not None:
@@ -2051,7 +2052,11 @@ class AgentManager:
                         except NoResultFound:
                             # Agent might not exist anymore, skip
                             continue
-            session.commit()
+
+            # TODO: @andy/caren
+            # TODO: Ideally we do two no commits on the update_async calls, and then commit here - but that errors for some reason?
+            # TODO: I have too many things rn so lets look at this later
+            # await session.commit()
 
             return await agent.to_pydantic_async()
 

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/services/file_processor/file_types.py

@@ -49,6 +49,7 @@ class FileTypeRegistry:
         self.register(".markdown", "text/markdown", True, "Markdown document", ChunkingStrategy.DOCUMENTATION)
         self.register(".json", "application/json", True, "JSON data file", ChunkingStrategy.STRUCTURED_DATA)
         self.register(".jsonl", "application/jsonl", True, "JSON Lines file", ChunkingStrategy.STRUCTURED_DATA)
+        self.register(".csv", "text/csv", True, "CSV data file", ChunkingStrategy.STRUCTURED_DATA)
 
         # Programming languages
         self.register(".py", "text/x-python", True, "Python source code", ChunkingStrategy.CODE)
@@ -137,6 +138,7 @@ class FileTypeRegistry:
         mimetypes.add_type("text/x-markdown", ".md")
         mimetypes.add_type("application/x-jsonlines", ".jsonl")
         mimetypes.add_type("text/xml", ".xml")
+        mimetypes.add_type("text/csv", ".csv")
 
     def get_allowed_media_types(self) -> Set[str]:
         """

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/letta/utils.py

@@ -531,6 +531,10 @@ def enforce_types(func):
             elif origin is list and isinstance(value, list):  # Handle List[T]
                 element_type = args[0] if args else None
                 return all(isinstance(v, element_type) for v in value) if element_type else True
+            elif origin is not None and (
+                str(origin).endswith("Literal") or getattr(origin, "_name", None) == "Literal"
+            ):  # Handle Literal types
+                return value in args
             elif origin:  # Handle other generics like Dict, Tuple, etc.
                 return isinstance(value, origin)
             else:  # Handle non-generic types

{letta_nightly-0.8.7.dev20250628104142 → letta_nightly-0.8.8.dev20250629225711}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.8.7.dev20250628104142"
+version = "0.8.8.dev20250629225711"
 packages = [
     {include = "letta"},
 ]