letta-nightly 0.8.9.dev20250706104157__tar.gz → 0.8.10.dev20250707035305__tar.gz

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.9.dev20250706104157
+Version: 0.8.10.dev20250707035305
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -75,6 +75,7 @@ Requires-Dist: pathvalidate (>=3.2.1,<4.0.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres" or extra == "desktop" or extra == "all"
 Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres" or extra == "desktop" or extra == "all"
+Requires-Dist: pinecone[asyncio] (>=7.3.0,<8.0.0)
 Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
 Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres" or extra == "desktop" or extra == "all"

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/__init__.py

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

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/agents/letta_agent.py

@@ -82,11 +82,16 @@ class LettaAgent(BaseAgent):
         step_manager: StepManager = NoopStepManager(),
         telemetry_manager: TelemetryManager = NoopTelemetryManager(),
         current_run_id: str | None = None,
+        ## summarizer settings
+        summarizer_mode: SummarizationMode = summarizer_settings.mode,
+        # for static_buffer mode
         summary_block_label: str = DEFAULT_SUMMARY_BLOCK_LABEL,
         message_buffer_limit: int = summarizer_settings.message_buffer_limit,
         message_buffer_min: int = summarizer_settings.message_buffer_min,
         enable_summarization: bool = summarizer_settings.enable_summarization,
         max_summarization_retries: int = summarizer_settings.max_summarization_retries,
+        # for partial_evict mode
+        partial_evict_summarizer_percentage: float = summarizer_settings.partial_evict_summarizer_percentage,
     ):
         super().__init__(agent_id=agent_id, openai_client=None, message_manager=message_manager, agent_manager=agent_manager, actor=actor)
 
@@ -124,11 +129,13 @@ class LettaAgent(BaseAgent):
             )
 
         self.summarizer = Summarizer(
-            mode=SummarizationMode(summarizer_settings.mode),
+            mode=summarizer_mode,
+            # TODO consolidate to not use this, or push it into the Summarizer() class
             summarizer_agent=self.summarization_agent,
             # TODO: Make this configurable
             message_buffer_limit=message_buffer_limit,
             message_buffer_min=message_buffer_min,
+            partial_evict_summarizer_percentage=partial_evict_summarizer_percentage,
         )
 
     async def _check_run_cancellation(self) -> bool:
@@ -872,25 +879,35 @@ class LettaAgent(BaseAgent):
             self.logger.warning(
                 f"Total tokens {total_tokens} exceeds configured max tokens {llm_config.context_window}, forcefully clearing message history."
             )
-            new_in_context_messages, updated = self.summarizer.summarize(
-                in_context_messages=in_context_messages, new_letta_messages=new_letta_messages, force=True, clear=True
+            new_in_context_messages, updated = await self.summarizer.summarize(
+                in_context_messages=in_context_messages,
+                new_letta_messages=new_letta_messages,
+                force=True,
+                clear=True,
             )
         else:
-            new_in_context_messages, updated = self.summarizer.summarize(
-                in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
+            self.logger.info(
+                f"Total tokens {total_tokens} does not exceed configured max tokens {llm_config.context_window}, passing summarizing w/o force."
+            )
+            new_in_context_messages, updated = await self.summarizer.summarize(
+                in_context_messages=in_context_messages,
+                new_letta_messages=new_letta_messages,
             )
         await self.agent_manager.set_in_context_messages_async(
-            agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
+            agent_id=self.agent_id,
+            message_ids=[m.id for m in new_in_context_messages],
+            actor=self.actor,
         )
 
         return new_in_context_messages
 
     @trace_method
     async def summarize_conversation_history(self) -> AgentState:
+        """Called when the developer explicitly triggers compaction via the API"""
         agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=self.agent_id, actor=self.actor)
         message_ids = agent_state.message_ids
         in_context_messages = await self.message_manager.get_messages_by_ids_async(message_ids=message_ids, actor=self.actor)
-        new_in_context_messages, updated = self.summarizer.summarize(
+        new_in_context_messages, updated = await self.summarizer.summarize(
             in_context_messages=in_context_messages, new_letta_messages=[], force=True
         )
         return await self.agent_manager.set_in_context_messages_async(

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/agents/voice_agent.py

@@ -295,7 +295,7 @@ class VoiceAgent(BaseAgent):
         new_letta_messages = await self.message_manager.create_many_messages_async(letta_message_db_queue, actor=self.actor)
 
         # TODO: Make this more general and configurable, less brittle
-        new_in_context_messages, updated = summarizer.summarize(
+        new_in_context_messages, updated = await summarizer.summarize(
             in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
         )
 

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/agents/voice_sleeptime_agent.py

@@ -90,7 +90,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         current_in_context_messages, new_in_context_messages, stop_reason, usage = await super()._step(
             agent_state=agent_state, input_messages=input_messages, max_steps=max_steps
         )
-        new_in_context_messages, updated = self.summarizer.summarize(
+        new_in_context_messages, updated = await self.summarizer.summarize(
             in_context_messages=current_in_context_messages, new_letta_messages=new_in_context_messages
         )
         self.agent_manager.set_in_context_messages(

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/constants.py

@@ -364,3 +364,10 @@ REDIS_RUN_ID_PREFIX = "agent:send_message:run_id"
 MAX_FILES_OPEN = 5
 
 GET_PROVIDERS_TIMEOUT_SECONDS = 10
+
+# Pinecone related fields
+PINECONE_EMBEDDING_MODEL: str = "llama-text-embed-v2"
+PINECONE_TEXT_FIELD_NAME = "chunk_text"
+PINECONE_METRIC = "cosine"
+PINECONE_CLOUD = "aws"
+PINECONE_REGION = "us-east-1"

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/functions/function_sets/files.py

@@ -65,7 +65,7 @@ async def grep_files(
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 
 
-async def semantic_search_files(agent_state: "AgentState", query: str) -> List["FileMetadata"]:
+async def semantic_search_files(agent_state: "AgentState", query: str, limit: int = 5) -> List["FileMetadata"]:
     """
     Get list of most relevant chunks from any file using vector/embedding search.
 
@@ -76,6 +76,7 @@ async def semantic_search_files(agent_state: "AgentState", query: str) -> List["
 
     Args:
         query (str): The search query.
+        limit: Maximum number of results to return (default: 5)
 
     Returns:
         List[FileMetadata]: List of matching files.

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/functions/functions.py

@@ -29,7 +29,6 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
             # "Field": Field,
         }
         env.update(globals())
-
         # print("About to execute source code...")
         exec(source_code, env)
         # print("Source code executed successfully")

letta_nightly-0.8.10.dev20250707035305/letta/helpers/pinecone_utils.py

@@ -0,0 +1,143 @@
+from typing import Any, Dict, List
+
+from pinecone import PineconeAsyncio
+
+from letta.constants import PINECONE_CLOUD, PINECONE_EMBEDDING_MODEL, PINECONE_METRIC, PINECONE_REGION, PINECONE_TEXT_FIELD_NAME
+from letta.log import get_logger
+from letta.schemas.user import User
+from letta.settings import settings
+
+logger = get_logger(__name__)
+
+
+def should_use_pinecone(verbose: bool = False):
+    if verbose:
+        logger.info(
+            "Pinecone check: enable_pinecone=%s, api_key=%s, agent_index=%s, source_index=%s",
+            settings.enable_pinecone,
+            bool(settings.pinecone_api_key),
+            bool(settings.pinecone_agent_index),
+            bool(settings.pinecone_source_index),
+        )
+
+    return settings.enable_pinecone and settings.pinecone_api_key and settings.pinecone_agent_index and settings.pinecone_source_index
+
+
+async def upsert_pinecone_indices():
+    from pinecone import IndexEmbed, PineconeAsyncio
+
+    for index_name in get_pinecone_indices():
+        async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+            if not await pc.has_index(index_name):
+                await pc.create_index_for_model(
+                    name=index_name,
+                    cloud=PINECONE_CLOUD,
+                    region=PINECONE_REGION,
+                    embed=IndexEmbed(model=PINECONE_EMBEDDING_MODEL, field_map={"text": PINECONE_TEXT_FIELD_NAME}, metric=PINECONE_METRIC),
+                )
+
+
+def get_pinecone_indices() -> List[str]:
+    return [settings.pinecone_agent_index, settings.pinecone_source_index]
+
+
+async def upsert_file_records_to_pinecone_index(file_id: str, source_id: str, chunks: List[str], actor: User):
+    records = []
+    for i, chunk in enumerate(chunks):
+        record = {
+            "_id": f"{file_id}_{i}",
+            PINECONE_TEXT_FIELD_NAME: chunk,
+            "file_id": file_id,
+            "source_id": source_id,
+        }
+        records.append(record)
+
+    return await upsert_records_to_pinecone_index(records, actor)
+
+
+async def delete_file_records_from_pinecone_index(file_id: str, actor: User):
+    from pinecone.exceptions.exceptions import NotFoundException
+
+    namespace = actor.organization_id
+    try:
+        async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+            description = await pc.describe_index(name=settings.pinecone_source_index)
+            async with pc.IndexAsyncio(host=description.index.host) as dense_index:
+                await dense_index.delete(
+                    filter={
+                        "file_id": {"$eq": file_id},
+                    },
+                    namespace=namespace,
+                )
+    except NotFoundException:
+        logger.warning(f"Pinecone namespace {namespace} not found for {file_id} and {actor.organization_id}")
+
+
+async def delete_source_records_from_pinecone_index(source_id: str, actor: User):
+    from pinecone.exceptions.exceptions import NotFoundException
+
+    namespace = actor.organization_id
+    try:
+        async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+            description = await pc.describe_index(name=settings.pinecone_source_index)
+            async with pc.IndexAsyncio(host=description.index.host) as dense_index:
+                await dense_index.delete(filter={"source_id": {"$eq": source_id}}, namespace=namespace)
+    except NotFoundException:
+        logger.warning(f"Pinecone namespace {namespace} not found for {source_id} and {actor.organization_id}")
+
+
+async def upsert_records_to_pinecone_index(records: List[dict], actor: User):
+    async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+        description = await pc.describe_index(name=settings.pinecone_source_index)
+        async with pc.IndexAsyncio(host=description.index.host) as dense_index:
+            await dense_index.upsert_records(actor.organization_id, records)
+
+
+async def search_pinecone_index(query: str, limit: int, filter: Dict[str, Any], actor: User) -> Dict[str, Any]:
+    async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+        description = await pc.describe_index(name=settings.pinecone_source_index)
+        async with pc.IndexAsyncio(host=description.index.host) as dense_index:
+            namespace = actor.organization_id
+
+            try:
+                # Search the dense index with reranking
+                search_results = await dense_index.search(
+                    namespace=namespace,
+                    query={
+                        "top_k": limit,
+                        "inputs": {"text": query},
+                        "filter": filter,
+                    },
+                    rerank={"model": "bge-reranker-v2-m3", "top_n": limit, "rank_fields": [PINECONE_TEXT_FIELD_NAME]},
+                )
+                return search_results
+            except Exception as e:
+                logger.warning(f"Failed to search Pinecone namespace {actor.organization_id}: {str(e)}")
+                raise e
+
+
+async def list_pinecone_index_for_files(file_id: str, actor: User, limit: int = None, pagination_token: str = None) -> List[str]:
+    from pinecone.exceptions.exceptions import NotFoundException
+
+    namespace = actor.organization_id
+    try:
+        async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
+            description = await pc.describe_index(name=settings.pinecone_source_index)
+            async with pc.IndexAsyncio(host=description.index.host) as dense_index:
+
+                kwargs = {"namespace": namespace, "prefix": file_id}
+                if limit is not None:
+                    kwargs["limit"] = limit
+                if pagination_token is not None:
+                    kwargs["pagination_token"] = pagination_token
+
+                try:
+                    result = []
+                    async for ids in dense_index.list(**kwargs):
+                        result.extend(ids)
+                    return result
+                except Exception as e:
+                    logger.warning(f"Failed to list Pinecone namespace {actor.organization_id}: {str(e)}")
+                    raise e
+    except NotFoundException:
+        logger.warning(f"Pinecone namespace {namespace} not found for {file_id} and {actor.organization_id}")

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/llm_api/openai_client.py

@@ -216,6 +216,10 @@ class OpenAIClient(LLMClientBase):
             # NOTE: the reasoners that don't support temperature require 1.0, not None
             temperature=llm_config.temperature if supports_temperature_param(model) else 1.0,
         )
+
+        if llm_config.frequency_penalty is not None:
+            data.frequency_penalty = llm_config.frequency_penalty
+
         if tools and supports_parallel_tool_calling(model):
             data.parallel_tool_calls = False
 

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/orm/file.py

@@ -60,6 +60,8 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
     )
 
     error_message: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Any error message encountered during processing.")
+    total_chunks: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, doc="Total number of chunks for the file.")
+    chunks_embedded: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, doc="Number of chunks that have been embedded.")
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="files", lazy="selectin")
@@ -112,6 +114,8 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
             file_last_modified_date=self.file_last_modified_date,
             processing_status=self.processing_status,
             error_message=self.error_message,
+            total_chunks=self.total_chunks,
+            chunks_embedded=self.chunks_embedded,
             created_at=self.created_at,
             updated_at=self.updated_at,
             is_deleted=self.is_deleted,

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/prompts/gpt_summarize.py

@@ -1,14 +1,12 @@
 WORD_LIMIT = 100
-SYSTEM = f"""
-Your job is to summarize a history of previous messages in a conversation between an AI persona and a human.
+SYSTEM = f"""Your job is to summarize a history of previous messages in a conversation between an AI persona and a human.
 The conversation you are given is a from a fixed context window and may not be complete.
 Messages sent by the AI are marked with the 'assistant' role.
-The AI 'assistant' can also make calls to functions, whose outputs can be seen in messages with the 'function' role.
+The AI 'assistant' can also make calls to tools, whose outputs can be seen in messages with the 'tool' role.
 Things the AI says in the message content are considered inner monologue and are not seen by the user.
 The only AI messages seen by the user are from when the AI uses 'send_message'.
 Messages the user sends are in the 'user' role.
 The 'user' role is also used for important system events, such as login events and heartbeat events (heartbeats run the AI's program without user action, allowing the AI to act without prompting from the user sending them a message).
-Summarize what happened in the conversation from the perspective of the AI (use the first person).
+Summarize what happened in the conversation from the perspective of the AI (use the first person from the perspective of the AI).
 Keep your summary less than {WORD_LIMIT} words, do NOT exceed this word limit.
-Only output the summary, do NOT include anything else in your output.
-"""
+Only output the summary, do NOT include anything else in your output."""

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/schemas/file.py

@@ -41,6 +41,8 @@ class FileMetadata(FileMetadataBase):
         description="The current processing status of the file (e.g. pending, parsing, embedding, completed, error).",
     )
     error_message: Optional[str] = Field(default=None, description="Optional error message if the file failed processing.")
+    total_chunks: Optional[int] = Field(default=None, description="Total number of chunks for the file.")
+    chunks_embedded: Optional[int] = Field(default=None, description="Number of chunks that have been embedded.")
 
     # orm metadata, optional fields
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
@@ -52,6 +54,10 @@ class FileMetadata(FileMetadataBase):
         default=None, description="Optional full-text content of the file; only populated on demand due to its size."
     )
 
+    def is_processing_terminal(self) -> bool:
+        """Check if the file processing status is in a terminal state (completed or error)."""
+        return self.processing_status in (FileProcessingStatus.COMPLETED, FileProcessingStatus.ERROR)
+
 
 class FileAgentBase(LettaBase):
     """Base class for the FileMetadata-⇄-Agent association schemas"""

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/schemas/letta_base.py

@@ -97,7 +97,7 @@ class LettaBase(BaseModel):
 
 class OrmMetadataBase(LettaBase):
     # metadata fields
-    created_by_id: Optional[str] = Field(None, description="The id of the user that made this object.")
-    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this object.")
-    created_at: Optional[datetime] = Field(None, description="The timestamp when the object was created.")
-    updated_at: Optional[datetime] = Field(None, description="The timestamp when the object was last updated.")
+    created_by_id: Optional[str] = Field(default=None, description="The id of the user that made this object.")
+    last_updated_by_id: Optional[str] = Field(default=None, description="The id of the user that made this object.")
+    created_at: Optional[datetime] = Field(default=None, description="The timestamp when the object was created.")
+    updated_at: Optional[datetime] = Field(default=None, description="The timestamp when the object was last updated.")

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/schemas/letta_message.py

@@ -72,7 +72,7 @@ class SystemMessage(LettaMessage):
         content (str): The message content sent by the system
     """
 
-    message_type: Literal[MessageType.system_message] = Field(MessageType.system_message, description="The type of the message.")
+    message_type: Literal[MessageType.system_message] = Field(default=MessageType.system_message, description="The type of the message.")
     content: str = Field(..., description="The message content sent by the system")
 
 
@@ -87,7 +87,7 @@ class UserMessage(LettaMessage):
         content (Union[str, List[LettaUserMessageContentUnion]]): The message content sent by the user (can be a string or an array of multi-modal content parts)
     """
 
-    message_type: Literal[MessageType.user_message] = Field(MessageType.user_message, description="The type of the message.")
+    message_type: Literal[MessageType.user_message] = Field(default=MessageType.user_message, description="The type of the message.")
     content: Union[str, List[LettaUserMessageContentUnion]] = Field(
         ...,
         description="The message content sent by the user (can be a string or an array of multi-modal content parts)",
@@ -109,7 +109,9 @@ class ReasoningMessage(LettaMessage):
         signature (Optional[str]): The model-generated signature of the reasoning step
     """
 
-    message_type: Literal[MessageType.reasoning_message] = Field(MessageType.reasoning_message, description="The type of the message.")
+    message_type: Literal[MessageType.reasoning_message] = Field(
+        default=MessageType.reasoning_message, description="The type of the message."
+    )
     source: Literal["reasoner_model", "non_reasoner_model"] = "non_reasoner_model"
     reasoning: str
     signature: Optional[str] = None
@@ -130,7 +132,7 @@ class HiddenReasoningMessage(LettaMessage):
     """
 
     message_type: Literal[MessageType.hidden_reasoning_message] = Field(
-        MessageType.hidden_reasoning_message, description="The type of the message."
+        default=MessageType.hidden_reasoning_message, description="The type of the message."
     )
     state: Literal["redacted", "omitted"]
     hidden_reasoning: Optional[str] = None
@@ -170,7 +172,9 @@ class ToolCallMessage(LettaMessage):
         tool_call (Union[ToolCall, ToolCallDelta]): The tool call
     """
 
-    message_type: Literal[MessageType.tool_call_message] = Field(MessageType.tool_call_message, description="The type of the message.")
+    message_type: Literal[MessageType.tool_call_message] = Field(
+        default=MessageType.tool_call_message, description="The type of the message."
+    )
     tool_call: Union[ToolCall, ToolCallDelta]
 
     def model_dump(self, *args, **kwargs):
@@ -222,7 +226,9 @@ class ToolReturnMessage(LettaMessage):
         stderr (Optional[List(str)]): Captured stderr from the tool invocation
     """
 
-    message_type: Literal[MessageType.tool_return_message] = Field(MessageType.tool_return_message, description="The type of the message.")
+    message_type: Literal[MessageType.tool_return_message] = Field(
+        default=MessageType.tool_return_message, description="The type of the message."
+    )
     tool_return: str
     status: Literal["success", "error"]
     tool_call_id: str
@@ -241,7 +247,9 @@ class AssistantMessage(LettaMessage):
         content (Union[str, List[LettaAssistantMessageContentUnion]]): The message content sent by the agent (can be a string or an array of content parts)
     """
 
-    message_type: Literal[MessageType.assistant_message] = Field(MessageType.assistant_message, description="The type of the message.")
+    message_type: Literal[MessageType.assistant_message] = Field(
+        default=MessageType.assistant_message, description="The type of the message."
+    )
     content: Union[str, List[LettaAssistantMessageContentUnion]] = Field(
         ...,
         description="The message content sent by the agent (can be a string or an array of content parts)",

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/schemas/letta_message_content.py

@@ -24,7 +24,7 @@ class MessageContent(BaseModel):
 
 
 class TextContent(MessageContent):
-    type: Literal[MessageContentType.text] = Field(MessageContentType.text, description="The type of the message.")
+    type: Literal[MessageContentType.text] = Field(default=MessageContentType.text, description="The type of the message.")
     text: str = Field(..., description="The text content of the message.")
 
 
@@ -44,27 +44,27 @@ class ImageSource(BaseModel):
 
 
 class UrlImage(ImageSource):
-    type: Literal[ImageSourceType.url] = Field(ImageSourceType.url, description="The source type for the image.")
+    type: Literal[ImageSourceType.url] = Field(default=ImageSourceType.url, description="The source type for the image.")
     url: str = Field(..., description="The URL of the image.")
 
 
 class Base64Image(ImageSource):
-    type: Literal[ImageSourceType.base64] = Field(ImageSourceType.base64, description="The source type for the image.")
+    type: Literal[ImageSourceType.base64] = Field(default=ImageSourceType.base64, description="The source type for the image.")
     media_type: str = Field(..., description="The media type for the image.")
     data: str = Field(..., description="The base64 encoded image data.")
     detail: Optional[str] = Field(
-        None,
+        default=None,
         description="What level of detail to use when processing and understanding the image (low, high, or auto to let the model decide)",
     )
 
 
 class LettaImage(ImageSource):
-    type: Literal[ImageSourceType.letta] = Field(ImageSourceType.letta, description="The source type for the image.")
+    type: Literal[ImageSourceType.letta] = Field(default=ImageSourceType.letta, description="The source type for the image.")
     file_id: str = Field(..., description="The unique identifier of the image file persisted in storage.")
-    media_type: Optional[str] = Field(None, description="The media type for the image.")
-    data: Optional[str] = Field(None, description="The base64 encoded image data.")
+    media_type: Optional[str] = Field(default=None, description="The media type for the image.")
+    data: Optional[str] = Field(default=None, description="The base64 encoded image data.")
     detail: Optional[str] = Field(
-        None,
+        default=None,
         description="What level of detail to use when processing and understanding the image (low, high, or auto to let the model decide)",
     )
 
@@ -73,7 +73,7 @@ ImageSourceUnion = Annotated[Union[UrlImage, Base64Image, LettaImage], Field(dis
 
 
 class ImageContent(MessageContent):
-    type: Literal[MessageContentType.image] = Field(MessageContentType.image, description="The type of the message.")
+    type: Literal[MessageContentType.image] = Field(default=MessageContentType.image, description="The type of the message.")
     source: ImageSourceUnion = Field(..., description="The source of the image.")
 
 
@@ -164,7 +164,7 @@ def get_letta_assistant_message_content_union_str_json_schema():
 
 class ToolCallContent(MessageContent):
     type: Literal[MessageContentType.tool_call] = Field(
-        MessageContentType.tool_call, description="Indicates this content represents a tool call event."
+        default=MessageContentType.tool_call, description="Indicates this content represents a tool call event."
     )
     id: str = Field(..., description="A unique identifier for this specific tool call instance.")
     name: str = Field(..., description="The name of the tool being called.")
@@ -175,7 +175,7 @@ class ToolCallContent(MessageContent):
 
 class ToolReturnContent(MessageContent):
     type: Literal[MessageContentType.tool_return] = Field(
-        MessageContentType.tool_return, description="Indicates this content represents a tool return event."
+        default=MessageContentType.tool_return, description="Indicates this content represents a tool return event."
     )
     tool_call_id: str = Field(..., description="References the ID of the ToolCallContent that initiated this tool call.")
     content: str = Field(..., description="The content returned by the tool execution.")
@@ -184,23 +184,23 @@ class ToolReturnContent(MessageContent):
 
 class ReasoningContent(MessageContent):
     type: Literal[MessageContentType.reasoning] = Field(
-        MessageContentType.reasoning, description="Indicates this is a reasoning/intermediate step."
+        default=MessageContentType.reasoning, description="Indicates this is a reasoning/intermediate step."
     )
     is_native: bool = Field(..., description="Whether the reasoning content was generated by a reasoner model that processed this step.")
     reasoning: str = Field(..., description="The intermediate reasoning or thought process content.")
-    signature: Optional[str] = Field(None, description="A unique identifier for this reasoning step.")
+    signature: Optional[str] = Field(default=None, description="A unique identifier for this reasoning step.")
 
 
 class RedactedReasoningContent(MessageContent):
     type: Literal[MessageContentType.redacted_reasoning] = Field(
-        MessageContentType.redacted_reasoning, description="Indicates this is a redacted thinking step."
+        default=MessageContentType.redacted_reasoning, description="Indicates this is a redacted thinking step."
     )
     data: str = Field(..., description="The redacted or filtered intermediate reasoning content.")
 
 
 class OmittedReasoningContent(MessageContent):
     type: Literal[MessageContentType.omitted_reasoning] = Field(
-        MessageContentType.omitted_reasoning, description="Indicates this is an omitted reasoning step."
+        default=MessageContentType.omitted_reasoning, description="Indicates this is an omitted reasoning step."
     )
     # NOTE: dropping because we don't track this kind of information for the other reasoning types
     # tokens: int = Field(..., description="The reasoning token count for intermediate reasoning content.")

{letta_nightly-0.8.9.dev20250706104157 → letta_nightly-0.8.10.dev20250707035305}/letta/schemas/llm_config.py

@@ -78,6 +78,10 @@ class LLMConfig(BaseModel):
         0,
         description="Configurable thinking budget for extended thinking. Used for enable_reasoner and also for Google Vertex models like Gemini 2.5 Flash. Minimum value is 1024 when used with enable_reasoner.",
     )
+    frequency_penalty: Optional[float] = Field(
+        None,  # Can also deafult to 0.0?
+        description="Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim. From OpenAI: Number between -2.0 and 2.0.",
+    )
 
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())