letta-nightly 0.12.0.dev20251009203644__py3-none-any.whl → 0.12.1.dev20251010012355__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.12.0"
+    __version__ = "0.12.1"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/adapters/simple_llm_stream_adapter.py

@@ -2,7 +2,7 @@ from typing import AsyncGenerator, List
 
 from letta.adapters.letta_llm_stream_adapter import LettaLLMStreamAdapter
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns
-from letta.interfaces.anthropic_streaming_interface import SimpleAnthropicStreamingInterface
+from letta.interfaces.anthropic_parallel_tool_call_streaming_interface import SimpleAnthropicStreamingInterface
 from letta.interfaces.gemini_streaming_interface import SimpleGeminiStreamingInterface
 from letta.interfaces.openai_streaming_interface import SimpleOpenAIResponsesStreamingInterface, SimpleOpenAIStreamingInterface
 from letta.schemas.enums import ProviderType

letta/agents/letta_agent_v2.py

@@ -99,16 +99,16 @@ class LettaAgentV2(BaseAgentV2):
         self.step_manager = StepManager()
         self.telemetry_manager = TelemetryManager()
 
-        # TODO: Expand to more
-        if summarizer_settings.enable_summarization and model_settings.openai_api_key:
-            self.summarization_agent = EphemeralSummaryAgent(
-                target_block_label="conversation_summary",
-                agent_id=self.agent_state.id,
-                block_manager=self.block_manager,
-                message_manager=self.message_manager,
-                agent_manager=self.agent_manager,
-                actor=self.actor,
-            )
+        ## TODO: Expand to more
+        # if summarizer_settings.enable_summarization and model_settings.openai_api_key:
+        #    self.summarization_agent = EphemeralSummaryAgent(
+        #        target_block_label="conversation_summary",
+        #        agent_id=self.agent_state.id,
+        #        block_manager=self.block_manager,
+        #        message_manager=self.message_manager,
+        #        agent_manager=self.agent_manager,
+        #        actor=self.actor,
+        #    )
 
         # Initialize summarizer for context window management
         self.summarizer = Summarizer(
@@ -117,7 +117,7 @@ class LettaAgentV2(BaseAgentV2):
                 if self.agent_state.agent_type == AgentType.voice_convo_agent
                 else summarizer_settings.mode
             ),
-            summarizer_agent=self.summarization_agent,
+            summarizer_agent=None,  # self.summarization_agent,
             message_buffer_limit=summarizer_settings.message_buffer_limit,
             message_buffer_min=summarizer_settings.message_buffer_min,
             partial_evict_summarizer_percentage=summarizer_settings.partial_evict_summarizer_percentage,

letta/interfaces/anthropic_parallel_tool_call_streaming_interface.py

@@ -0,0 +1,487 @@
+import asyncio
+import json
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Optional
+
+from anthropic import AsyncStream
+from anthropic.types.beta import (
+    BetaInputJSONDelta,
+    BetaRawContentBlockDeltaEvent,
+    BetaRawContentBlockStartEvent,
+    BetaRawContentBlockStopEvent,
+    BetaRawMessageDeltaEvent,
+    BetaRawMessageStartEvent,
+    BetaRawMessageStopEvent,
+    BetaRawMessageStreamEvent,
+    BetaRedactedThinkingBlock,
+    BetaSignatureDelta,
+    BetaTextBlock,
+    BetaTextDelta,
+    BetaThinkingBlock,
+    BetaThinkingDelta,
+    BetaToolUseBlock,
+)
+
+from letta.log import get_logger
+from letta.schemas.letta_message import (
+    ApprovalRequestMessage,
+    AssistantMessage,
+    HiddenReasoningMessage,
+    LettaMessage,
+    ReasoningMessage,
+    ToolCallDelta,
+    ToolCallMessage,
+)
+from letta.schemas.letta_message_content import ReasoningContent, RedactedReasoningContent, TextContent
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
+from letta.server.rest_api.json_parser import JSONParser, PydanticJSONParser
+
+logger = get_logger(__name__)
+
+
+# TODO: These modes aren't used right now - but can be useful we do multiple sequential tool calling within one Claude message
+class EventMode(Enum):
+    TEXT = "TEXT"
+    TOOL_USE = "TOOL_USE"
+    THINKING = "THINKING"
+    REDACTED_THINKING = "REDACTED_THINKING"
+
+
+# TODO: There's a duplicate version of this in anthropic_streaming_interface
+class SimpleAnthropicStreamingInterface:
+    """
+    A simpler version of AnthropicStreamingInterface focused on streaming assistant text and
+    tool call deltas. Updated to support parallel tool calling by collecting completed
+    ToolUse blocks (from content_block stop events) and exposing all finalized tool calls
+    via get_tool_call_objects().
+
+    Notes:
+    - We keep emitting the stream (text and tool-call deltas) as before for latency.
+    - We no longer rely on accumulating partial JSON to build the final tool call; instead
+      we read the finalized ToolUse input from the stop event and store it.
+    - Multiple tool calls within a single message (parallel tool use) are collected and
+      can be returned to the agent as a list.
+    """
+
+    def __init__(
+        self,
+        requires_approval_tools: list = [],
+        run_id: str | None = None,
+        step_id: str | None = None,
+    ):
+        self.json_parser: JSONParser = PydanticJSONParser()
+        self.run_id = run_id
+        self.step_id = step_id
+
+        # Premake IDs for database writes
+        self.letta_message_id = Message.generate_id()
+
+        self.anthropic_mode = None
+        self.message_id = None
+        self.accumulated_inner_thoughts = []
+        self.tool_call_id = None
+        self.tool_call_name = None
+        self.accumulated_tool_call_args = ""
+        self.previous_parse = {}
+
+        # usage trackers
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.model = None
+
+        # reasoning object trackers
+        self.reasoning_messages = []
+
+        # assistant object trackers
+        self.assistant_messages: list[AssistantMessage] = []
+
+        # Buffer to hold tool call messages until inner thoughts are complete
+        self.tool_call_buffer = []
+        self.inner_thoughts_complete = False
+
+        # Buffer to handle partial XML tags across chunks
+        self.partial_tag_buffer = ""
+
+        self.requires_approval_tools = requires_approval_tools
+        # Collected finalized tool calls (supports parallel tool use)
+        self.collected_tool_calls: list[ToolCall] = []
+        # Track active tool_use blocks by stream index for parallel tool calling
+        # { index: {"id": str, "name": str, "args": str} }
+        self.active_tool_uses: dict[int, dict[str, str]] = {}
+        # Maintain start order and indexed collection for stable ordering
+        self._tool_use_start_order: list[int] = []
+        self._collected_indexed: list[tuple[int, ToolCall]] = []
+
+    def get_tool_call_objects(self) -> list[ToolCall]:
+        """Return all finalized tool calls collected during this message (parallel supported)."""
+        # Prefer indexed ordering if available
+        if self._collected_indexed:
+            return [
+                call
+                for _, call in sorted(
+                    self._collected_indexed,
+                    key=lambda x: self._tool_use_start_order.index(x[0]) if x[0] in self._tool_use_start_order else x[0],
+                )
+            ]
+        return self.collected_tool_calls
+
+    # This exists for legacy compatibility
+    def get_tool_call_object(self) -> Optional[ToolCall]:
+        tool_calls = self.get_tool_call_objects()
+        if tool_calls:
+            return tool_calls[0]
+        return None
+
+    def get_reasoning_content(self) -> list[TextContent | ReasoningContent | RedactedReasoningContent]:
+        def _process_group(
+            group: list[ReasoningMessage | HiddenReasoningMessage | AssistantMessage],
+            group_type: str,
+        ) -> TextContent | ReasoningContent | RedactedReasoningContent:
+            if group_type == "reasoning":
+                reasoning_text = "".join(chunk.reasoning for chunk in group).strip()
+                is_native = any(chunk.source == "reasoner_model" for chunk in group)
+                signature = next((chunk.signature for chunk in group if chunk.signature is not None), None)
+                if is_native:
+                    return ReasoningContent(is_native=is_native, reasoning=reasoning_text, signature=signature)
+                else:
+                    return TextContent(text=reasoning_text)
+            elif group_type == "redacted":
+                redacted_text = "".join(chunk.hidden_reasoning for chunk in group if chunk.hidden_reasoning is not None)
+                return RedactedReasoningContent(data=redacted_text)
+            elif group_type == "text":
+                concat = ""
+                for chunk in group:
+                    if isinstance(chunk.content, list):
+                        concat += "".join([c.text for c in chunk.content])
+                    else:
+                        concat += chunk.content
+                return TextContent(text=concat)
+            else:
+                raise ValueError("Unexpected group type")
+
+        merged = []
+        current_group = []
+        current_group_type = None  # "reasoning" or "redacted"
+
+        for msg in self.reasoning_messages:
+            # Determine the type of the current message
+            if isinstance(msg, HiddenReasoningMessage):
+                msg_type = "redacted"
+            elif isinstance(msg, ReasoningMessage):
+                msg_type = "reasoning"
+            elif isinstance(msg, AssistantMessage):
+                msg_type = "text"
+            else:
+                raise ValueError("Unexpected message type")
+
+            # Initialize group type if not set
+            if current_group_type is None:
+                current_group_type = msg_type
+
+            # If the type changes, process the current group
+            if msg_type != current_group_type:
+                merged.append(_process_group(current_group, current_group_type))
+                current_group = []
+                current_group_type = msg_type
+
+            current_group.append(msg)
+
+        # Process the final group, if any.
+        if current_group:
+            merged.append(_process_group(current_group, current_group_type))
+
+        return merged
+
+    def get_content(self) -> list[TextContent | ReasoningContent | RedactedReasoningContent]:
+        return self.get_reasoning_content()
+
+    async def process(
+        self,
+        stream: AsyncStream[BetaRawMessageStreamEvent],
+        ttft_span: Optional["Span"] = None,
+    ) -> AsyncGenerator[LettaMessage | LettaStopReason, None]:
+        prev_message_type = None
+        message_index = 0
+        event = None
+        try:
+            async with stream:
+                async for event in stream:
+                    try:
+                        async for message in self._process_event(event, ttft_span, prev_message_type, message_index):
+                            new_message_type = message.message_type
+                            if new_message_type != prev_message_type:
+                                if prev_message_type != None:
+                                    message_index += 1
+                                prev_message_type = new_message_type
+                            # print(f"Yielding message: {message}")
+                            yield message
+                    except asyncio.CancelledError as e:
+                        import traceback
+
+                        logger.info("Cancelled stream attempt but overriding %s: %s", e, traceback.format_exc())
+                        async for message in self._process_event(event, ttft_span, prev_message_type, message_index):
+                            new_message_type = message.message_type
+                            if new_message_type != prev_message_type:
+                                if prev_message_type != None:
+                                    message_index += 1
+                                prev_message_type = new_message_type
+                            yield message
+
+                        # Don't raise the exception here
+                        continue
+
+        except Exception as e:
+            import traceback
+
+            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            if ttft_span:
+                ttft_span.add_event(
+                    name="stop_reason",
+                    attributes={"stop_reason": StopReasonType.error.value, "error": str(e), "stacktrace": traceback.format_exc()},
+                )
+            yield LettaStopReason(stop_reason=StopReasonType.error)
+            raise e
+        finally:
+            logger.info("AnthropicStreamingInterface: Stream processing complete.")
+
+    async def _process_event(
+        self,
+        event: BetaRawMessageStreamEvent,
+        ttft_span: Optional["Span"] = None,
+        prev_message_type: Optional[str] = None,
+        message_index: int = 0,
+    ) -> AsyncGenerator[LettaMessage | LettaStopReason, None]:
+        """Process a single event from the Anthropic stream and yield any resulting messages.
+
+        Args:
+            event: The event to process
+
+        Yields:
+            Messages generated from processing this event
+        """
+        if isinstance(event, BetaRawContentBlockStartEvent):
+            content = event.content_block
+
+            if isinstance(content, BetaTextBlock):
+                self.anthropic_mode = EventMode.TEXT
+                # TODO: Can capture citations, etc.
+
+            elif isinstance(content, BetaToolUseBlock):
+                # New tool_use block started at this index
+                self.anthropic_mode = EventMode.TOOL_USE
+                self.active_tool_uses[event.index] = {"id": content.id, "name": content.name, "args": ""}
+                if event.index not in self._tool_use_start_order:
+                    self._tool_use_start_order.append(event.index)
+
+                # Emit an initial tool call delta for this new block
+                name = content.name
+                call_id = content.id
+                # Initialize arguments from the start event's input (often {}) to avoid undefined in UIs
+                if name in self.requires_approval_tools:
+                    if prev_message_type and prev_message_type != "approval_request_message":
+                        message_index += 1
+                    tool_call_msg = ApprovalRequestMessage(
+                        id=self.letta_message_id,
+                        # Do not emit placeholder arguments here to avoid UI duplicates
+                        tool_call=ToolCallDelta(name=name, tool_call_id=call_id),
+                        date=datetime.now(timezone.utc).isoformat(),
+                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        run_id=self.run_id,
+                        step_id=self.step_id,
+                    )
+                else:
+                    if prev_message_type and prev_message_type != "tool_call_message":
+                        message_index += 1
+                    tool_call_msg = ToolCallMessage(
+                        id=self.letta_message_id,
+                        # Do not emit placeholder arguments here to avoid UI duplicates
+                        tool_call=ToolCallDelta(name=name, tool_call_id=call_id),
+                        date=datetime.now(timezone.utc).isoformat(),
+                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        run_id=self.run_id,
+                        step_id=self.step_id,
+                    )
+                prev_message_type = tool_call_msg.message_type
+                yield tool_call_msg
+
+            elif isinstance(content, BetaThinkingBlock):
+                self.anthropic_mode = EventMode.THINKING
+                # TODO: Can capture signature, etc.
+
+            elif isinstance(content, BetaRedactedThinkingBlock):
+                self.anthropic_mode = EventMode.REDACTED_THINKING
+
+                if prev_message_type and prev_message_type != "hidden_reasoning_message":
+                    message_index += 1
+
+                hidden_reasoning_message = HiddenReasoningMessage(
+                    id=self.letta_message_id,
+                    state="redacted",
+                    hidden_reasoning=content.data,
+                    date=datetime.now(timezone.utc).isoformat(),
+                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                    run_id=self.run_id,
+                    step_id=self.step_id,
+                )
+
+                self.reasoning_messages.append(hidden_reasoning_message)
+                prev_message_type = hidden_reasoning_message.message_type
+                yield hidden_reasoning_message
+
+        elif isinstance(event, BetaRawContentBlockDeltaEvent):
+            delta = event.delta
+
+            if isinstance(delta, BetaTextDelta):
+                # Safety check
+                if not self.anthropic_mode == EventMode.TEXT:
+                    raise RuntimeError(f"Streaming integrity failed - received BetaTextDelta object while not in TEXT EventMode: {delta}")
+
+                if prev_message_type and prev_message_type != "assistant_message":
+                    message_index += 1
+
+                assistant_msg = AssistantMessage(
+                    id=self.letta_message_id,
+                    # content=[TextContent(text=delta.text)],
+                    content=delta.text,
+                    date=datetime.now(timezone.utc).isoformat(),
+                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                    run_id=self.run_id,
+                    step_id=self.step_id,
+                )
+                # self.assistant_messages.append(assistant_msg)
+                self.reasoning_messages.append(assistant_msg)
+                prev_message_type = assistant_msg.message_type
+                yield assistant_msg
+
+            elif isinstance(delta, BetaInputJSONDelta):
+                # Append partial JSON for the specific tool_use block at this index
+                if not self.anthropic_mode == EventMode.TOOL_USE:
+                    raise RuntimeError(
+                        f"Streaming integrity failed - received BetaInputJSONDelta object while not in TOOL_USE EventMode: {delta}"
+                    )
+
+                ctx = self.active_tool_uses.get(event.index)
+                if ctx is None:
+                    # Defensive: initialize if missing
+                    self.active_tool_uses[event.index] = {"id": self.tool_call_id or "", "name": self.tool_call_name or "", "args": ""}
+                    ctx = self.active_tool_uses[event.index]
+
+                # Append only non-empty partials
+                if delta.partial_json:
+                    ctx["args"] += delta.partial_json
+                else:
+                    # Skip streaming a no-op delta to prevent duplicate placeholders in UI
+                    return
+
+                name = ctx.get("name")
+                call_id = ctx.get("id")
+
+                if name in self.requires_approval_tools:
+                    if prev_message_type and prev_message_type != "approval_request_message":
+                        message_index += 1
+                    tool_call_msg = ApprovalRequestMessage(
+                        id=self.letta_message_id,
+                        tool_call=ToolCallDelta(name=name, tool_call_id=call_id, arguments=delta.partial_json),
+                        date=datetime.now(timezone.utc).isoformat(),
+                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        run_id=self.run_id,
+                        step_id=self.step_id,
+                    )
+                else:
+                    if prev_message_type and prev_message_type != "tool_call_message":
+                        message_index += 1
+                    tool_call_msg = ToolCallMessage(
+                        id=self.letta_message_id,
+                        tool_call=ToolCallDelta(name=name, tool_call_id=call_id, arguments=delta.partial_json),
+                        date=datetime.now(timezone.utc).isoformat(),
+                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        run_id=self.run_id,
+                        step_id=self.step_id,
+                    )
+
+                yield tool_call_msg
+
+            elif isinstance(delta, BetaThinkingDelta):
+                # Safety check
+                if not self.anthropic_mode == EventMode.THINKING:
+                    raise RuntimeError(
+                        f"Streaming integrity failed - received BetaThinkingBlock object while not in THINKING EventMode: {delta}"
+                    )
+
+                if prev_message_type and prev_message_type != "reasoning_message":
+                    message_index += 1
+                reasoning_message = ReasoningMessage(
+                    id=self.letta_message_id,
+                    source="reasoner_model",
+                    reasoning=delta.thinking,
+                    date=datetime.now(timezone.utc).isoformat(),
+                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                    run_id=self.run_id,
+                    step_id=self.step_id,
+                )
+                self.reasoning_messages.append(reasoning_message)
+                prev_message_type = reasoning_message.message_type
+                yield reasoning_message
+
+            elif isinstance(delta, BetaSignatureDelta):
+                # Safety check
+                if not self.anthropic_mode == EventMode.THINKING:
+                    raise RuntimeError(
+                        f"Streaming integrity failed - received BetaSignatureDelta object while not in THINKING EventMode: {delta}"
+                    )
+
+                if prev_message_type and prev_message_type != "reasoning_message":
+                    message_index += 1
+                reasoning_message = ReasoningMessage(
+                    id=self.letta_message_id,
+                    source="reasoner_model",
+                    reasoning="",
+                    date=datetime.now(timezone.utc).isoformat(),
+                    signature=delta.signature,
+                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                    run_id=self.run_id,
+                    step_id=self.step_id,
+                )
+                self.reasoning_messages.append(reasoning_message)
+                prev_message_type = reasoning_message.message_type
+                yield reasoning_message
+
+        elif isinstance(event, BetaRawMessageStartEvent):
+            self.message_id = event.message.id
+            self.input_tokens += event.message.usage.input_tokens
+            self.output_tokens += event.message.usage.output_tokens
+            self.model = event.message.model
+
+        elif isinstance(event, BetaRawMessageDeltaEvent):
+            self.output_tokens += event.usage.output_tokens
+
+        elif isinstance(event, BetaRawMessageStopEvent):
+            # Don't do anything here! We don't want to stop the stream.
+            pass
+
+        elif isinstance(event, BetaRawContentBlockStopEvent):
+            # Finalize the tool_use block at this index using accumulated deltas
+            ctx = self.active_tool_uses.pop(event.index, None)
+            if ctx is not None and ctx.get("id") and ctx.get("name") is not None:
+                raw_args = ctx.get("args", "")
+                try:
+                    # Prefer strict JSON load, fallback to permissive parser
+                    tool_input = json.loads(raw_args) if raw_args else {}
+                except json.JSONDecodeError:
+                    try:
+                        tool_input = self.json_parser.parse(raw_args) if raw_args else {}
+                    except Exception:
+                        tool_input = {}
+
+                arguments = json.dumps(tool_input)
+                finalized = ToolCall(id=ctx["id"], function=FunctionCall(arguments=arguments, name=ctx["name"]))
+                # Keep both raw list and indexed list for compatibility
+                self.collected_tool_calls.append(finalized)
+                self._collected_indexed.append((event.index, finalized))
+
+            # Reset mode when a content block ends
+            self.anthropic_mode = None

letta/llm_api/openai_client.py

@@ -420,6 +420,17 @@ class OpenAIClient(LLMClientBase):
             logger.warning(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
             model = None
 
+        # TODO: we may need to extend this to more models using proxy?
+        is_openrouter = (llm_config.model_endpoint and "openrouter.ai" in llm_config.model_endpoint) or (
+            llm_config.provider_name == "openrouter"
+        )
+        if is_openrouter:
+            try:
+                model = llm_config.handle.split("/", 1)[-1]
+            except:
+                # don't raise error since this isn't robust against edge cases
+                pass
+
         # force function calling for reliability, see https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most

letta/schemas/environment_variables.py

@@ -3,6 +3,8 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+from letta.schemas.secret import Secret
+from letta.settings import settings
 
 
 # Base Environment Variable
@@ -13,6 +15,28 @@ class EnvironmentVariableBase(OrmMetadataBase):
     description: Optional[str] = Field(None, description="An optional description of the environment variable.")
     organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
 
+    # Encrypted field (stored as Secret object, serialized to string for DB)
+    # Secret class handles validation and serialization automatically via __get_pydantic_core_schema__
+    value_enc: Secret | None = Field(None, description="Encrypted value as Secret object")
+
+    def get_value_secret(self) -> Secret:
+        """Get the value as a Secret object, preferring encrypted over plaintext."""
+        # If value_enc is already a Secret, return it
+        if self.value_enc is not None:
+            return self.value_enc
+        # Otherwise, create from plaintext value
+        return Secret.from_db(None, self.value)
+
+    def set_value_secret(self, secret: Secret) -> None:
+        """Set value from a Secret object, directly storing the Secret."""
+        self.value_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.value = secret_dict["plaintext"]
+        else:
+            self.value = None
+
 
 class EnvironmentVariableCreateBase(LettaBase):
     key: str = Field(..., description="The name of the environment variable.")

letta/schemas/providers/base.py

@@ -8,6 +8,7 @@ from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.llm_config_overrides import LLM_HANDLE_OVERRIDES
+from letta.schemas.secret import Secret
 from letta.settings import model_settings
 
 
@@ -28,8 +29,14 @@ class Provider(ProviderBase):
     organization_id: str | None = Field(None, description="The organization id of the user")
     updated_at: datetime | None = Field(None, description="The last update timestamp of the provider.")
 
+    # Encrypted fields (stored as Secret objects, serialized to strings for DB)
+    # Secret class handles validation and serialization automatically via __get_pydantic_core_schema__
+    api_key_enc: Secret | None = Field(None, description="Encrypted API key as Secret object")
+    access_key_enc: Secret | None = Field(None, description="Encrypted access key as Secret object")
+
     @model_validator(mode="after")
     def default_base_url(self):
+        # Set default base URL
         if self.provider_type == ProviderType.openai and self.base_url is None:
             self.base_url = model_settings.openai_api_base
         return self
@@ -38,6 +45,42 @@ class Provider(ProviderBase):
         if not self.id:
             self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
 
+    def get_api_key_secret(self) -> Secret:
+        """Get the API key as a Secret object, preferring encrypted over plaintext."""
+        # If api_key_enc is already a Secret, return it
+        if self.api_key_enc is not None:
+            return self.api_key_enc
+        # Otherwise, create from plaintext api_key
+        return Secret.from_db(None, self.api_key)
+
+    def get_access_key_secret(self) -> Secret:
+        """Get the access key as a Secret object, preferring encrypted over plaintext."""
+        # If access_key_enc is already a Secret, return it
+        if self.access_key_enc is not None:
+            return self.access_key_enc
+        # Otherwise, create from plaintext access_key
+        return Secret.from_db(None, self.access_key)
+
+    def set_api_key_secret(self, secret: Secret) -> None:
+        """Set API key from a Secret object, directly storing the Secret."""
+        self.api_key_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.api_key = secret_dict["plaintext"]
+        else:
+            self.api_key = None
+
+    def set_access_key_secret(self, secret: Secret) -> None:
+        """Set access key from a Secret object, directly storing the Secret."""
+        self.access_key_enc = secret
+        # Also update plaintext field for dual-write during migration
+        secret_dict = secret.to_dict()
+        if not secret.was_encrypted:
+            self.access_key = secret_dict["plaintext"]
+        else:
+            self.access_key = None
+
     async def check_api_key(self):
         """Check if the API key is valid for the provider"""
         raise NotImplementedError

letta/schemas/secret.py

@@ -2,6 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, ConfigDict, PrivateAttr
+from pydantic_core import core_schema
 
 from letta.helpers.crypto_utils import CryptoUtils
 from letta.log import get_logger
@@ -19,16 +20,16 @@ class Secret(BaseModel):
     TODO: Once we deprecate plaintext columns in the database:
     - Remove the dual-write logic in to_dict()
     - Remove the from_db() method's plaintext_value parameter
-    - Remove the _was_encrypted flag (no longer needed for migration)
+    - Remove the was_encrypted flag (no longer needed for migration)
     - Simplify get_plaintext() to only handle encrypted values
     """
 
-    # Store the encrypted value
-    _encrypted_value: Optional[str] = PrivateAttr(default=None)
-    # Cache the decrypted value to avoid repeated decryption
+    # Store the encrypted value as a regular field
+    encrypted_value: Optional[str] = None
+    # Cache the decrypted value to avoid repeated decryption (not serialized for security)
     _plaintext_cache: Optional[str] = PrivateAttr(default=None)
     # Flag to indicate if the value was originally encrypted
-    _was_encrypted: bool = PrivateAttr(default=False)
+    was_encrypted: bool = False
 
     model_config = ConfigDict(frozen=True)
 
@@ -44,18 +45,16 @@ class Secret(BaseModel):
             A Secret instance with the encrypted value, or plaintext if encryption unavailable
         """
         if value is None:
-            instance = cls()
-            instance._encrypted_value = None
-            instance._was_encrypted = False
-            return instance
+            return cls.model_construct(encrypted_value=None, was_encrypted=False)
+
+        # Guard against double encryption - check if value is already encrypted
+        if CryptoUtils.is_encrypted(value):
+            logger.warning("Creating Secret from already-encrypted value. This can be dangerous.")
 
         # Try to encrypt, but fall back to plaintext if no encryption key
         try:
             encrypted = CryptoUtils.encrypt(value)
-            instance = cls()
-            instance._encrypted_value = encrypted
-            instance._was_encrypted = False
-            return instance
+            return cls.model_construct(encrypted_value=encrypted, was_encrypted=False)
         except ValueError as e:
             # No encryption key available, store as plaintext
             if "No encryption key configured" in str(e):
@@ -63,10 +62,8 @@ class Secret(BaseModel):
                     "No encryption key configured. Storing Secret value as plaintext. "
                     "Set LETTA_ENCRYPTION_KEY environment variable to enable encryption."
                 )
-                instance = cls()
-                instance._encrypted_value = value  # Store plaintext
+                instance = cls.model_construct(encrypted_value=value, was_encrypted=False)
                 instance._plaintext_cache = value  # Cache it
-                instance._was_encrypted = False
                 return instance
             raise  # Re-raise if it's a different error
 
@@ -81,10 +78,7 @@ class Secret(BaseModel):
         Returns:
             A Secret instance
         """
-        instance = cls()
-        instance._encrypted_value = encrypted_value
-        instance._was_encrypted = True
-        return instance
+        return cls.model_construct(encrypted_value=encrypted_value, was_encrypted=True)
 
     @classmethod
     def from_db(cls, encrypted_value: Optional[str], plaintext_value: Optional[str]) -> "Secret":
@@ -114,7 +108,7 @@ class Secret(BaseModel):
         Returns:
             The encrypted value, or None if the secret is empty
         """
-        return self._encrypted_value
+        return self.encrypted_value
 
     def get_plaintext(self) -> Optional[str]:
         """
@@ -126,7 +120,7 @@ class Secret(BaseModel):
         Returns:
             The decrypted plaintext value
         """
-        if self._encrypted_value is None:
+        if self.encrypted_value is None:
             return None
 
         # Use cached value if available, but only if it looks like plaintext
@@ -134,14 +128,14 @@ class Secret(BaseModel):
         if self._plaintext_cache is not None:
             # If we have a cache but the stored value looks encrypted and we have no key,
             # we should not use the cache
-            if CryptoUtils.is_encrypted(self._encrypted_value) and not CryptoUtils.is_encryption_available():
+            if CryptoUtils.is_encrypted(self.encrypted_value) and not CryptoUtils.is_encryption_available():
                 self._plaintext_cache = None  # Clear invalid cache
             else:
                 return self._plaintext_cache
 
         # Decrypt and cache
         try:
-            plaintext = CryptoUtils.decrypt(self._encrypted_value)
+            plaintext = CryptoUtils.decrypt(self.encrypted_value)
             # Cache the decrypted value (PrivateAttr fields can be mutated even with frozen=True)
             self._plaintext_cache = plaintext
             return plaintext
@@ -151,7 +145,7 @@ class Secret(BaseModel):
             # Handle missing encryption key
             if "No encryption key configured" in error_msg:
                 # Check if the value looks encrypted
-                if CryptoUtils.is_encrypted(self._encrypted_value):
+                if CryptoUtils.is_encrypted(self.encrypted_value):
                     # Value was encrypted, but now we have no key - can't decrypt
                     logger.warning(
                         "Cannot decrypt Secret value - no encryption key configured. "
@@ -162,26 +156,26 @@ class Secret(BaseModel):
                 else:
                     # Value is plaintext (stored when no key was available)
                     logger.debug("Secret value is plaintext (stored without encryption)")
-                    self._plaintext_cache = self._encrypted_value
-                    return self._encrypted_value
+                    self._plaintext_cache = self.encrypted_value
+                    return self.encrypted_value
 
             # Handle decryption failure (might be plaintext stored as such)
             elif "Failed to decrypt data" in error_msg:
                 # Check if it might be plaintext
-                if not CryptoUtils.is_encrypted(self._encrypted_value):
+                if not CryptoUtils.is_encrypted(self.encrypted_value):
                     # It's plaintext that was stored when no key was available
                     logger.debug("Secret value appears to be plaintext (stored without encryption)")
-                    self._plaintext_cache = self._encrypted_value
-                    return self._encrypted_value
+                    self._plaintext_cache = self.encrypted_value
+                    return self.encrypted_value
                 # Otherwise, it's corrupted or wrong key
                 logger.error("Failed to decrypt Secret value - data may be corrupted or wrong key")
                 raise
 
             # Migration case: handle legacy plaintext
-            elif not self._was_encrypted:
-                if self._encrypted_value and not CryptoUtils.is_encrypted(self._encrypted_value):
-                    self._plaintext_cache = self._encrypted_value
-                    return self._encrypted_value
+            elif not self.was_encrypted:
+                if self.encrypted_value and not CryptoUtils.is_encrypted(self.encrypted_value):
+                    self._plaintext_cache = self.encrypted_value
+                    return self.encrypted_value
                 return None
 
             # Re-raise for other errors
@@ -189,7 +183,7 @@ class Secret(BaseModel):
 
     def is_empty(self) -> bool:
         """Check if the secret is empty/None."""
-        return self._encrypted_value is None
+        return self.encrypted_value is None
 
     def __str__(self) -> str:
         """String representation that doesn't expose the actual value."""
@@ -207,7 +201,7 @@ class Secret(BaseModel):
 
         Returns both encrypted and plaintext values for dual-write during migration.
         """
-        return {"encrypted": self.get_encrypted(), "plaintext": self.get_plaintext() if not self._was_encrypted else None}
+        return {"encrypted": self.get_encrypted(), "plaintext": self.get_plaintext() if not self.was_encrypted else None}
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -219,6 +213,79 @@ class Secret(BaseModel):
             return False
         return self.get_plaintext() == other.get_plaintext()
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler) -> core_schema.CoreSchema:
+        """
+        Customize Pydantic's validation and serialization behavior for Secret fields.
+
+        This allows Secret fields to automatically:
+        - Deserialize: Convert encrypted strings from DB → Secret objects
+        - Serialize: Convert Secret objects → encrypted strings for DB
+        """
+
+        def validate_secret(value: Any) -> "Secret":
+            """Convert various input types to Secret objects."""
+            if isinstance(value, Secret):
+                return value
+            elif isinstance(value, str):
+                # String from DB is assumed to be encrypted
+                return Secret.from_encrypted(value)
+            elif isinstance(value, dict):
+                # Dict might be from Pydantic serialization - check for encrypted_value key
+                if "encrypted_value" in value:
+                    # This is a serialized Secret being deserialized
+                    return cls(**value)
+                elif not value or value == {}:
+                    # Empty dict means None
+                    return Secret.from_plaintext(None)
+                else:
+                    raise ValueError(f"Cannot convert dict to Secret: {value}")
+            elif value is None:
+                return Secret.from_plaintext(None)
+            else:
+                raise ValueError(f"Cannot convert {type(value)} to Secret")
+
+        def serialize_secret(secret: "Secret") -> Optional[str]:
+            """Serialize Secret to encrypted string."""
+            if secret is None:
+                return None
+            return secret.get_encrypted()
+
+        python_schema = core_schema.chain_schema(
+            [
+                core_schema.no_info_plain_validator_function(validate_secret),
+                core_schema.is_instance_schema(cls),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=python_schema,
+            python_schema=python_schema,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                serialize_secret,
+                when_used="always",
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, core_schema: core_schema.CoreSchema, handler) -> Dict[str, Any]:
+        """
+        Define JSON schema representation for Secret fields.
+        In JSON schema (OpenAPI docs), Secret fields appear as nullable strings.
+        The actual encryption/decryption happens at runtime via __get_pydantic_core_schema__.
+        Args:
+            core_schema: The core schema for this type
+            handler: Handler for generating JSON schema
+        Returns:
+            A JSON schema dict representing this type as a nullable string
+        """
+        # Return a simple string schema for JSON schema generation
+        return {
+            "type": "string",
+            "nullable": True,
+            "description": "Encrypted secret value (stored as encrypted string)",
+        }
+
 
 class SecretDict(BaseModel):
     """

letta/settings.py

@@ -329,6 +329,9 @@ class Settings(BaseSettings):
     file_processing_timeout_minutes: int = 30
     file_processing_timeout_error_message: str = "File processing timed out after {} minutes. Please try again."
 
+    # enabling letta_agent_v1 architecture
+    use_letta_v1_agent: bool = False
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:

{letta_nightly-0.12.0.dev20251009203644.dist-info → letta_nightly-0.12.1.dev20251010012355.dist-info}/METADATA

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

{letta_nightly-0.12.0.dev20251009203644.dist-info → letta_nightly-0.12.1.dev20251010012355.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=YF1Hcr7H49Jrjsp2dkyB-FWzee4pnuGLJnLBERmmsi0,1620
+letta/__init__.py,sha256=dpn9tUBW7H4GEY_umGCKhKfZA9qu8S1F1ZPBPFuJJIA,1620
 letta/agent.py,sha256=xP13DDysFq-h3Ny7DiTN5ZC2txRripMNvPFt8dfFDbE,89498
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
 letta/constants.py,sha256=Yxp2DGlVnesnevIQbXqfYadxvVuYYk_6-lsF7YmHixs,16255
@@ -10,7 +10,7 @@ letta/log.py,sha256=-hkEaSIru3cvO8ynHPWb91jemJHzgWjmVc3fqGJrjvU,2294
 letta/main.py,sha256=A0e4EXoW9XdlCzJ8EyMQaukjNhu_8XI0_FIiwyHTENM,458
 letta/memory.py,sha256=xE1gAm99_PN0mWi4EL5CEIE95y9XFD4G0rHKTkO17-w,4325
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/settings.py,sha256=CbSbYJ21q8MSrWJBie0YxXC2ijmPLNr7mojU4DPZuH4,15810
+letta/settings.py,sha256=r7yRYXiWsdJnBUvFmEPLVHuiBTuvtrDem-TtUsmNPM4,15891
 letta/streaming_interface.py,sha256=rPMfwUcjqITWk2tVqFQm1hmP99tU2IOHg9gU2dgPSo8,16400
 letta/streaming_utils.py,sha256=ZRFGFpQqn9ujCEbgZdLM7yTjiuNNvqQ47sNhV8ix-yQ,16553
 letta/system.py,sha256=NClLhwB9Dw20L6IDPpfcnmxXqYQlA5E92xzJ0hGPLo0,8993
@@ -19,7 +19,7 @@ letta/adapters/letta_llm_adapter.py,sha256=Uo9l2lUI-n9mymWlK8lTResdWx0mc-F_ttmmK
 letta/adapters/letta_llm_request_adapter.py,sha256=ApEaMOkvtH5l09NvVgm0r2qaqTnGSqwVqAFA7n5N1HA,4757
 letta/adapters/letta_llm_stream_adapter.py,sha256=p31xPQ-pU4SYPImlC6frl3cnVltSdCzO-NDD2Q7W8L0,7859
 letta/adapters/simple_llm_request_adapter.py,sha256=LmzawoEqqcqAeqvdmWikRUZRnb3BriMN71IyyOm-uJo,3734
-letta/adapters/simple_llm_stream_adapter.py,sha256=a7SK4qBFGEEH1ttq6I2H5f-cfPojwvmyYBI5Q1nscPY,8879
+letta/adapters/simple_llm_stream_adapter.py,sha256=Rq-m48GQ7jdWaCAsDQd6li6HL0s_7VREi8pE2OLYIO0,8898
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/agent_loop.py,sha256=IODUozq61N73V55stSN65QLBs9nCD9IHtFTJHr51E0c,1120
 letta/agents/base_agent.py,sha256=TAc5quD9KRMKOurz_-ZHoAPZe13ZWFlE6sDjaPqN-fk,8518
@@ -30,7 +30,7 @@ letta/agents/exceptions.py,sha256=BQY4D4w32OYHM63CM19ko7dPwZiAzUs3NbKvzmCTcJg,31
 letta/agents/helpers.py,sha256=Hz8dKczPxMmDh-ILiUAEHgT55hMgIHO1yV8Vo0PORcw,16837
 letta/agents/letta_agent.py,sha256=4SSx6aORD28B1IogEoWeCTQr4jBaniX9jJolD4pssaQ,98156
 letta/agents/letta_agent_batch.py,sha256=NizNeIHvFtG4XpZCIplOSF8GohwHvNEkAUvsFBSdtSs,27950
-letta/agents/letta_agent_v2.py,sha256=MBoXVMIPixozb3xts2Bl8BCbExMIv3vtGbKZK1RitT4,60101
+letta/agents/letta_agent_v2.py,sha256=vRUDrkFhRl-HRfoYMm3z_T6msjuMo7kt5itQdIHE09A,60121
 letta/agents/letta_agent_v3.py,sha256=i8idcEKVcZxJk67T_g0zLFBcrlHfygcuN9V_xk4Sj0c,48081
 letta/agents/voice_agent.py,sha256=DP7g7TPFhaIAxmpur9yyJVI8Sb_MnoWfpHm7Q-t7mJI,23177
 letta/agents/voice_sleeptime_agent.py,sha256=_JzCbWBOKrmo1cTaqZFTrQudpJEapwAyrXYtAHUILGo,8675
@@ -88,6 +88,7 @@ letta/humans/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/humans/examples/basic.txt,sha256=Lcp8YESTWvOJgO4Yf_yyQmgo5bKakeB1nIVrwEGG6PA,17
 letta/humans/examples/cs_phd.txt,sha256=9C9ZAV_VuG7GB31ksy3-_NAyk8rjE6YtVOkhp08k1xw,297
 letta/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+letta/interfaces/anthropic_parallel_tool_call_streaming_interface.py,sha256=c65ULgokOuO-zbg_ek4cnHytIxcNx9AfTYOOaAnCMLY,21820
 letta/interfaces/anthropic_streaming_interface.py,sha256=VaqI_aLAOk8EbVmDLe8PMOb5LsKNhVqpgVbLe-WbjMg,44780
 letta/interfaces/gemini_streaming_interface.py,sha256=1nJwGl3nKAL7yfDX0zzpWrrjjpqzRFo82JpsEF6u_cA,12406
 letta/interfaces/openai_chat_completions_streaming_interface.py,sha256=3xHXh8cW79EkiMUTYfvcH_s92nkLjxXfvtVOVC3bfLo,5050
@@ -113,7 +114,7 @@ letta/llm_api/llm_client.py,sha256=iXiPbrhluP2DBczv9nkFlAXdwWGOkg0lNDA9LzLrG4o,3
 letta/llm_api/llm_client_base.py,sha256=31I1ancGiAaNBRMGbVkaBDgJ0Tu1cc0XLlTnjUllqbM,10085
 letta/llm_api/mistral.py,sha256=ruOTBt07Uzx7S30_eXhedVWngtpjtlzG6Ox1Iw0_mQs,662
 letta/llm_api/openai.py,sha256=loY0N97Ot_TyNZhNyPCZsFv3NHOXZyLNiecvLvZT1hs,28771
-letta/llm_api/openai_client.py,sha256=nY_X7OWl1OUwuG2mcTr19dRhX9LC23vKflCokegEzhg,41606
+letta/llm_api/openai_client.py,sha256=hKBU0PshJNeYXLvio3fvaDUEHjQbDoqJNSyOUE6wi3o,42070
 letta/llm_api/together_client.py,sha256=HeDMDDa525yfDTKciODDfX_t93QBfFmX0n2P-FT1QTU,2284
 letta/llm_api/xai_client.py,sha256=_hlZrNeGy86hix-vTUcDe_3TrVnn6wSBHv1tI2YtGAQ,3941
 letta/llm_api/sample_response_jsons/aws_bedrock.json,sha256=RS3VqyxPB9hQQCPm42hWoga0bisKv_0e8ZF-c3Ag1FA,930
@@ -253,7 +254,7 @@ letta/schemas/block.py,sha256=SIHjoxgwl9JmJROmntznIZSA0OJBdbj4R58OUjg3RdU,7960
 letta/schemas/embedding_config.py,sha256=ZaD40UeeAX6A9C6bQVhrKwNDiMEuOn7-5uHcj9_T_D0,3740
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
 letta/schemas/enums.py,sha256=9G968IVdkrCzJ-cU0_GJZDosQdk7qMlvC8_a0ylh_v8,5704
-letta/schemas/environment_variables.py,sha256=VRtzOjdeQdHcSHXisk7oJUQlheruxhSWNS0xqlfGzbs,2429
+letta/schemas/environment_variables.py,sha256=XX_fk_rDaBd3r5ORnynewNIml0he5JdWdGE3NS5cTyM,3533
 letta/schemas/file.py,sha256=78aTJuYqhhTu95hKFmcJmCa5_wJMZ521aiRzPM2plAM,6242
 letta/schemas/folder.py,sha256=OpTj9idfGx6CEKDySeDEu3ZNDYjl8jJ02CH96RWPAVk,3309
 letta/schemas/group.py,sha256=X4ioNEUraBa_pGN1bNBNugkQieGMLvh6rXisFgcHwoo,8663
@@ -284,7 +285,7 @@ letta/schemas/response_format.py,sha256=b2onyfSDCxnNkSHd4NsfJg_4ni5qBIK_F6zeJoMv
 letta/schemas/run.py,sha256=wjpDNsgme51WVr5EJ12Px6qhtOYbw-PMpJP32lche14,3630
 letta/schemas/run_metrics.py,sha256=xbeObgpP-0guO3RRvEfEK5YNV6G7ol4whx3_ds88mIk,1147
 letta/schemas/sandbox_config.py,sha256=iw3-QS7PNy649tdynTJUxBbaruprykYAuGO6q28w-gU,5974
-letta/schemas/secret.py,sha256=1vq33Z-Oe2zSeVnGuj6j04YoO0Y9LxX1bmkprg6C1NA,15659
+letta/schemas/secret.py,sha256=grMrOGFDRf5JHw9xtacD0KxCk89OGdTzO67zkFMYr8c,18737
 letta/schemas/source.py,sha256=Uxsm8-XA3vuIt5Ihu_l2Aau7quuqmyIDg7qIryklUqY,3565
 letta/schemas/source_metadata.py,sha256=_dGjuXhGcVMlc53ja9yuk16Uj64ggEzilRDgmkqYfNs,1334
 letta/schemas/step.py,sha256=rPT20AvHk31iGZRblp1tXbAgKedE4JZQKhu3RkvymrE,3572
@@ -303,7 +304,7 @@ letta/schemas/openai/responses_request.py,sha256=7UlZt2XProhRZ9L_oUQ5HrD9wPxDzvB
 letta/schemas/providers/__init__.py,sha256=3_8xegx1svx31qAupfpIZ4MmeW1_2FRmxZbhjfLnSZo,1405
 letta/schemas/providers/anthropic.py,sha256=CWvCN2wAf6PyrgQy1dDv-MoYwYSaw3f-wzzNUaeXTkY,6835
 letta/schemas/providers/azure.py,sha256=c0aSfKdVwS_4wWnqng4fe_jmXGmvICRES-8nmqzoEpg,7692
-letta/schemas/providers/base.py,sha256=xGIsj7py0p8xp4LXvarDxhTxU93LF88HhCpvenBB0eo,10074
+letta/schemas/providers/base.py,sha256=_Zven0SepeI3kBwpTKA3oapXWBxoUk4FdBAxckgLvTI,12121
 letta/schemas/providers/bedrock.py,sha256=_8HPjLQ3KKj2x2zINUVbqbHxToXDOhkbQA2A3bDFntU,3634
 letta/schemas/providers/cerebras.py,sha256=tFPN_LTJL_rzRE0DvXHb5Ckyaw4534X2kmibhWjHlA8,3208
 letta/schemas/providers/deepseek.py,sha256=FXu8qPedeQC2Cn_L-k-1sQjj4feB8mbmW9XMJYx5hjE,2623
@@ -476,8 +477,8 @@ letta/templates/sandbox_code_file.py.j2,sha256=eXga5J_04Z8-pGdwfOCDjcRnMceIqcF5i
 letta/templates/sandbox_code_file_async.py.j2,sha256=lb7nh_P2W9VZHzU_9TxSCEMUod7SDziPXgvT75xVds0,2748
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta_nightly-0.12.0.dev20251009203644.dist-info/METADATA,sha256=P1HTklX5YTlDe3BCg-vOF-NsHMseJx7r19qrHXzPft4,24468
-letta_nightly-0.12.0.dev20251009203644.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.12.0.dev20251009203644.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.12.0.dev20251009203644.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.12.0.dev20251009203644.dist-info/RECORD,,
+letta_nightly-0.12.1.dev20251010012355.dist-info/METADATA,sha256=aoPdv79qrEbohSKR-WbKaoRViQCJCcCzNcjjXtsTvSs,24468
+letta_nightly-0.12.1.dev20251010012355.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.12.1.dev20251010012355.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.12.1.dev20251010012355.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.12.1.dev20251010012355.dist-info/RECORD,,