letta-nightly 0.8.17.dev20250723104501__py3-none-any.whl → 0.9.0.dev20250724081419__py3-none-any.whl

letta/llm_api/openai.py

@@ -59,11 +59,15 @@ def openai_check_valid_api_key(base_url: str, api_key: Union[str, None]) -> None
 
 def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool = False, extra_params: Optional[dict] = None) -> dict:
     """https://platform.openai.com/docs/api-reference/models/list"""
-    from letta.utils import printd
 
     # In some cases we may want to double-check the URL and do basic correction, eg:
     # In Letta config the address for vLLM is w/o a /v1 suffix for simplicity
     # However if we're treating the server as an OpenAI proxy we want the /v1 suffix on our model hit
+
+    import warnings
+
+    warnings.warn("The synchronous version of openai_get_model_list function is deprecated. Use the async one instead.", DeprecationWarning)
+
     if fix_url:
         if not url.endswith("/v1"):
             url = smart_urljoin(url, "v1")
@@ -74,14 +78,14 @@ def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool
     if api_key is not None:
         headers["Authorization"] = f"Bearer {api_key}"
 
-    printd(f"Sending request to {url}")
+    logger.debug(f"Sending request to {url}")
     response = None
     try:
         # TODO add query param "tool" to be true
         response = requests.get(url, headers=headers, params=extra_params)
         response.raise_for_status()  # Raises HTTPError for 4XX/5XX status
         response = response.json()  # convert to dict from string
-        printd(f"response = {response}")
+        logger.debug(f"response = {response}")
         return response
     except requests.exceptions.HTTPError as http_err:
         # Handle HTTP errors (e.g., response 4XX, 5XX)
@@ -90,7 +94,7 @@ def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool
                 response = response.json()
         except:
             pass
-        printd(f"Got HTTPError, exception={http_err}, response={response}")
+        logger.debug(f"Got HTTPError, exception={http_err}, response={response}")
         raise http_err
     except requests.exceptions.RequestException as req_err:
         # Handle other requests-related errors (e.g., connection error)
@@ -99,7 +103,7 @@ def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool
                 response = response.json()
         except:
             pass
-        printd(f"Got RequestException, exception={req_err}, response={response}")
+        logger.debug(f"Got RequestException, exception={req_err}, response={response}")
         raise req_err
     except Exception as e:
         # Handle other potential errors
@@ -108,7 +112,7 @@ def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool
                 response = response.json()
         except:
             pass
-        printd(f"Got unknown Exception, exception={e}, response={response}")
+        logger.debug(f"Got unknown Exception, exception={e}, response={response}")
         raise e
 
 
@@ -120,7 +124,6 @@ async def openai_get_model_list_async(
     client: Optional["httpx.AsyncClient"] = None,
 ) -> dict:
     """https://platform.openai.com/docs/api-reference/models/list"""
-    from letta.utils import printd
 
     # In some cases we may want to double-check the URL and do basic correction
     if fix_url and not url.endswith("/v1"):
@@ -132,7 +135,7 @@ async def openai_get_model_list_async(
     if api_key is not None:
         headers["Authorization"] = f"Bearer {api_key}"
 
-    printd(f"Sending request to {url}")
+    logger.debug(f"Sending request to {url}")
 
     # Use provided client or create a new one
     close_client = False
@@ -144,24 +147,23 @@ async def openai_get_model_list_async(
         response = await client.get(url, headers=headers, params=extra_params)
         response.raise_for_status()
         result = response.json()
-        printd(f"response = {result}")
+        logger.debug(f"response = {result}")
         return result
     except httpx.HTTPStatusError as http_err:
         # Handle HTTP errors (e.g., response 4XX, 5XX)
-        error_response = None
         try:
             error_response = http_err.response.json()
         except:
             error_response = {"status_code": http_err.response.status_code, "text": http_err.response.text}
-        printd(f"Got HTTPError, exception={http_err}, response={error_response}")
+        logger.debug(f"Got HTTPError, exception={http_err}, response={error_response}")
         raise http_err
     except httpx.RequestError as req_err:
         # Handle other httpx-related errors (e.g., connection error)
-        printd(f"Got RequestException, exception={req_err}")
+        logger.debug(f"Got RequestException, exception={req_err}")
         raise req_err
     except Exception as e:
         # Handle other potential errors
-        printd(f"Got unknown Exception, exception={e}")
+        logger.debug(f"Got unknown Exception, exception={e}")
         raise e
     finally:
         if close_client:
@@ -480,7 +482,7 @@ def openai_chat_completions_process_stream(
                                     )
 
                 if message_delta.function_call is not None:
-                    raise NotImplementedError(f"Old function_call style not support with stream=True")
+                    raise NotImplementedError("Old function_call style not support with stream=True")
 
             # overwrite response fields based on latest chunk
             if not create_message_id:
@@ -503,7 +505,7 @@ def openai_chat_completions_process_stream(
         logger.error(f"Parsing ChatCompletion stream failed with error:\n{str(e)}")
         raise e
     finally:
-        logger.info(f"Finally ending streaming interface.")
+        logger.info("Finally ending streaming interface.")
         if stream_interface:
             stream_interface.stream_end()
 
@@ -525,7 +527,6 @@ def openai_chat_completions_process_stream(
 
     assert len(chat_completion_response.choices) > 0, f"No response from provider {chat_completion_response}"
 
-    # printd(chat_completion_response)
     log_event(name="llm_response_received", attributes=chat_completion_response.model_dump())
     return chat_completion_response
 
@@ -536,7 +537,6 @@ def openai_chat_completions_request_stream(
     chat_completion_request: ChatCompletionRequest,
     fix_url: bool = False,
 ) -> Generator[ChatCompletionChunkResponse, None, None]:
-
     # In some cases we may want to double-check the URL and do basic correction, eg:
     # In Letta config the address for vLLM is w/o a /v1 suffix for simplicity
     # However if we're treating the server as an OpenAI proxy we want the /v1 suffix on our model hit

letta/llm_api/sample_response_jsons/aws_bedrock.json

@@ -0,0 +1,38 @@
+{
+    "id": "msg_123",
+    "type": "message",
+    "role": "assistant",
+    "model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+    "content": [
+        {
+            "type": "text",
+            "text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
+        },
+        {
+            "type": "tool_use",
+            "id": "toolu_123",
+            "name": "computer",
+            "input": {
+                "action": "mouse_move",
+                "coordinate": [
+                    708,
+                    736
+                ]
+            }
+        },
+        {
+            "type": "tool_use",
+            "id": "toolu_234",
+            "name": "computer",
+            "input": {
+                "action": "left_click"
+            }
+        }
+    ],
+    "stop_reason": "tool_use",
+    "stop_sequence": null,
+    "usage": {
+        "input_tokens": 3391,
+        "output_tokens": 132
+    }
+}

letta/llm_api/sample_response_jsons/lmstudio_embedding_list.json

@@ -0,0 +1,15 @@
+{
+  "object": "list",
+  "data": [
+    {
+      "id": "text-embedding-nomic-embed-text-v1.5",
+      "object": "model",
+      "type": "embeddings",
+      "publisher": "nomic-ai",
+      "arch": "nomic-bert",
+      "compatibility_type": "gguf",
+      "quantization": "Q4_0",
+      "state": "not-loaded",
+      "max_context_length": 2048
+    },
+    ...

letta/llm_api/sample_response_jsons/lmstudio_model_list.json

@@ -0,0 +1,15 @@
+        {
+          "object": "list",
+          "data": [
+            {
+              "id": "qwen2-vl-7b-instruct",
+              "object": "model",
+              "type": "vlm",
+              "publisher": "mlx-community",
+              "arch": "qwen2_vl",
+              "compatibility_type": "mlx",
+              "quantization": "4bit",
+              "state": "not-loaded",
+              "max_context_length": 32768
+            },
+            ...,

letta/local_llm/constants.py

@@ -1,32 +1,11 @@
-# import letta.local_llm.llm_chat_completion_wrappers.airoboros as airoboros
 from letta.local_llm.llm_chat_completion_wrappers.chatml import ChatMLInnerMonologueWrapper
 
-DEFAULT_ENDPOINTS = {
-    # Local
-    "koboldcpp": "http://localhost:5001",
-    "llamacpp": "http://localhost:8080",
-    "lmstudio": "http://localhost:1234",
-    "lmstudio-legacy": "http://localhost:1234",
-    "ollama": "http://localhost:11434",
-    "webui-legacy": "http://localhost:5000",
-    "webui": "http://localhost:5000",
-    "vllm": "http://localhost:8000",
-    # APIs
-    "openai": "https://api.openai.com",
-    "anthropic": "https://api.anthropic.com",
-    "groq": "https://api.groq.com/openai",
-}
-
-DEFAULT_OLLAMA_MODEL = "dolphin2.2-mistral:7b-q6_K"
-
-# DEFAULT_WRAPPER = airoboros.Airoboros21InnerMonologueWrapper
-# DEFAULT_WRAPPER_NAME = "airoboros-l2-70b-2.1"
-
 DEFAULT_WRAPPER = ChatMLInnerMonologueWrapper
 DEFAULT_WRAPPER_NAME = "chatml"
 
-INNER_THOUGHTS_KWARG = "inner_thoughts"
+INNER_THOUGHTS_KWARG = "thinking"
 INNER_THOUGHTS_KWARG_VERTEX = "thinking"
+VALID_INNER_THOUGHTS_KWARGS = ("thinking", "inner_thoughts")
 INNER_THOUGHTS_KWARG_DESCRIPTION = "Deep inner monologue private to you only."
 INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST = f"Deep inner monologue private to you only. Think before you act, so always generate arg '{INNER_THOUGHTS_KWARG}' first before any other arg."
 INNER_THOUGHTS_CLI_SYMBOL = "💭"

letta/local_llm/json_parser.py

@@ -1,5 +1,6 @@
 import json
 import re
+import warnings
 
 from letta.errors import LLMJSONParsingError
 from letta.helpers.json_helpers import json_loads
@@ -77,10 +78,19 @@ def add_missing_heartbeat(llm_json):
 
 
 def clean_and_interpret_send_message_json(json_string):
+    from letta.local_llm.constants import INNER_THOUGHTS_KWARG, VALID_INNER_THOUGHTS_KWARGS
+    from letta.settings import model_settings
+
+    kwarg = model_settings.inner_thoughts_kwarg
+    if kwarg not in VALID_INNER_THOUGHTS_KWARGS:
+        warnings.warn(f"INNER_THOUGHTS_KWARG is not valid: {kwarg}")
+        kwarg = INNER_THOUGHTS_KWARG
+
     # If normal parsing fails, attempt to clean and extract manually
     cleaned_json_string = re.sub(r"[^\x00-\x7F]+", "", json_string)  # Remove non-ASCII characters
     function_match = re.search(r'"function":\s*"send_message"', cleaned_json_string)
-    inner_thoughts_match = re.search(r'"inner_thoughts":\s*"([^"]+)"', cleaned_json_string)
+
+    inner_thoughts_match = re.search(rf'"{kwarg}":\s*"([^"]+)"', cleaned_json_string)
     message_match = re.search(r'"message":\s*"([^"]+)"', cleaned_json_string)
 
     if function_match and inner_thoughts_match and message_match:

letta/local_llm/llm_chat_completion_wrappers/airoboros.py

@@ -75,7 +75,7 @@ class Airoboros21Wrapper(LLMChatCompletionWrapper):
             func_str = ""
             func_str += f"{schema['name']}:"
             func_str += f"\n  description: {schema['description']}"
-            func_str += f"\n  params:"
+            func_str += "\n  params:"
             for param_k, param_v in schema["parameters"]["properties"].items():
                 # TODO we're ignoring type
                 func_str += f"\n    {param_k}: {param_v['description']}"
@@ -83,8 +83,8 @@ class Airoboros21Wrapper(LLMChatCompletionWrapper):
             return func_str
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         if function_documentation is not None:
             prompt += f"\n{function_documentation}"
         else:
@@ -150,7 +150,7 @@ class Airoboros21Wrapper(LLMChatCompletionWrapper):
             prompt += "\n### RESPONSE"
 
         if self.include_assistant_prefix:
-            prompt += f"\nASSISTANT:"
+            prompt += "\nASSISTANT:"
             if self.include_opening_brance_in_prefix:
                 prompt += "\n{"
 
@@ -282,9 +282,9 @@ class Airoboros21InnerMonologueWrapper(Airoboros21Wrapper):
             func_str = ""
             func_str += f"{schema['name']}:"
             func_str += f"\n  description: {schema['description']}"
-            func_str += f"\n  params:"
+            func_str += "\n  params:"
             if add_inner_thoughts:
-                func_str += f"\n    inner_thoughts: Deep inner monologue private to you only."
+                func_str += "\n    inner_thoughts: Deep inner monologue private to you only."
             for param_k, param_v in schema["parameters"]["properties"].items():
                 # TODO we're ignoring type
                 func_str += f"\n    {param_k}: {param_v['description']}"
@@ -292,8 +292,8 @@ class Airoboros21InnerMonologueWrapper(Airoboros21Wrapper):
             return func_str
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         if function_documentation is not None:
             prompt += f"\n{function_documentation}"
         else:
@@ -375,7 +375,7 @@ class Airoboros21InnerMonologueWrapper(Airoboros21Wrapper):
             prompt += "\n### RESPONSE"
 
         if self.include_assistant_prefix:
-            prompt += f"\nASSISTANT:"
+            prompt += "\nASSISTANT:"
             if self.assistant_prefix_extra:
                 prompt += self.assistant_prefix_extra
 

letta/local_llm/llm_chat_completion_wrappers/chatml.py

@@ -71,7 +71,7 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
         func_str = ""
         func_str += f"{schema['name']}:"
         func_str += f"\n  description: {schema['description']}"
-        func_str += f"\n  params:"
+        func_str += "\n  params:"
         if add_inner_thoughts:
             from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
 
@@ -87,8 +87,8 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
         prompt = ""
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         for function_dict in functions:
             prompt += f"\n{self._compile_function_description(function_dict)}"
 
@@ -101,8 +101,8 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
         prompt += system_message
         prompt += "\n"
         if function_documentation is not None:
-            prompt += f"Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-            prompt += f"\nAvailable functions:\n"
+            prompt += "Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+            prompt += "\nAvailable functions:\n"
             prompt += function_documentation
         else:
             prompt += self._compile_function_block(functions)
@@ -230,7 +230,6 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
                 prompt += f"\n<|im_start|>{role_str}\n{msg_str.strip()}<|im_end|>"
 
             elif message["role"] == "system":
-
                 role_str = "system"
                 msg_str = self._compile_system_message(
                     system_message=message["content"], functions=functions, function_documentation=function_documentation
@@ -255,7 +254,7 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
                 raise ValueError(message)
 
         if self.include_assistant_prefix:
-            prompt += f"\n<|im_start|>assistant"
+            prompt += "\n<|im_start|>assistant"
             if self.assistant_prefix_hint:
                 prompt += f"\n{FIRST_PREFIX_HINT if first_message else PREFIX_HINT}"
             if self.supports_first_message and first_message:
@@ -386,7 +385,7 @@ class ChatMLOuterInnerMonologueWrapper(ChatMLInnerMonologueWrapper):
                 "You must always include inner thoughts, but you do not always have to call a function.",
             ]
         )
-        prompt += f"\nAvailable functions:"
+        prompt += "\nAvailable functions:"
         for function_dict in functions:
             prompt += f"\n{self._compile_function_description(function_dict, add_inner_thoughts=False)}"
 

letta/local_llm/llm_chat_completion_wrappers/configurable_wrapper.py

@@ -91,9 +91,9 @@ class ConfigurableJSONWrapper(LLMChatCompletionWrapper):
         func_str = ""
         func_str += f"{schema['name']}:"
         func_str += f"\n  description: {schema['description']}"
-        func_str += f"\n  params:"
+        func_str += "\n  params:"
         if add_inner_thoughts:
-            func_str += f"\n    inner_thoughts: Deep inner monologue private to you only."
+            func_str += "\n    inner_thoughts: Deep inner monologue private to you only."
         for param_k, param_v in schema["parameters"]["properties"].items():
             # TODO we're ignoring type
             func_str += f"\n    {param_k}: {param_v['description']}"
@@ -105,8 +105,8 @@ class ConfigurableJSONWrapper(LLMChatCompletionWrapper):
         prompt = ""
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         for function_dict in functions:
             prompt += f"\n{self._compile_function_description(function_dict)}"
 
@@ -117,8 +117,8 @@ class ConfigurableJSONWrapper(LLMChatCompletionWrapper):
         prompt = system_message
         prompt += "\n"
         if function_documentation is not None:
-            prompt += f"Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-            prompt += f"\nAvailable functions:"
+            prompt += "Please select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+            prompt += "\nAvailable functions:"
             prompt += function_documentation
         else:
             prompt += self._compile_function_block(functions)

letta/local_llm/llm_chat_completion_wrappers/dolphin.py

@@ -85,7 +85,7 @@ class Dolphin21MistralWrapper(LLMChatCompletionWrapper):
             func_str = ""
             func_str += f"{schema['name']}:"
             func_str += f"\n  description: {schema['description']}"
-            func_str += f"\n  params:"
+            func_str += "\n  params:"
             for param_k, param_v in schema["parameters"]["properties"].items():
                 # TODO we're ignoring type
                 func_str += f"\n    {param_k}: {param_v['description']}"
@@ -93,8 +93,8 @@ class Dolphin21MistralWrapper(LLMChatCompletionWrapper):
             return func_str
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         if function_documentation is not None:
             prompt += f"\n{function_documentation}"
         else:

letta/local_llm/llm_chat_completion_wrappers/simple_summary_wrapper.py

@@ -124,7 +124,7 @@ class SimpleSummaryWrapper(LLMChatCompletionWrapper):
 
         if self.include_assistant_prefix:
             # prompt += f"\nASSISTANT:"
-            prompt += f"\nSUMMARY:"
+            prompt += "\nSUMMARY:"
 
         # print(prompt)
         return prompt

letta/local_llm/ollama/api.py

@@ -18,7 +18,7 @@ def get_ollama_completion(endpoint, auth_type, auth_key, model, prompt, context_
 
     if model is None:
         raise LocalLLMError(
-            f"Error: model name not specified. Set model in your config to the model you want to run (e.g. 'dolphin2.2-mistral')"
+            "Error: model name not specified. Set model in your config to the model you want to run (e.g. 'dolphin2.2-mistral')"
         )
 
     # Settings for the generation, includes the prompt + stop tokens, max length, etc
@@ -51,7 +51,7 @@ def get_ollama_completion(endpoint, auth_type, auth_key, model, prompt, context_
     # Set grammar
     if grammar is not None:
         # request["grammar_string"] = load_grammar_file(grammar)
-        raise NotImplementedError(f"Ollama does not support grammars")
+        raise NotImplementedError("Ollama does not support grammars")
 
     if not endpoint.startswith(("http://", "https://")):
         raise ValueError(f"Provided OPENAI_API_BASE value ({endpoint}) must begin with http:// or https://")

letta/orm/__init__.py

@@ -20,6 +20,7 @@ from letta.orm.mcp_server import MCPServer
 from letta.orm.message import Message
 from letta.orm.organization import Organization
 from letta.orm.passage import AgentPassage, BasePassage, SourcePassage
+from letta.orm.prompt import Prompt
 from letta.orm.provider import Provider
 from letta.orm.provider_trace import ProviderTrace
 from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable

letta/orm/agent.py

@@ -20,6 +20,7 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.response_format import ResponseFormatUnion
 from letta.schemas.tool_rule import ToolRule
+from letta.utils import calculate_file_defaults_based_on_context_window
 
 if TYPE_CHECKING:
     from letta.orm.agents_tags import AgentsTags
@@ -92,6 +93,14 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
     # timezone
     timezone: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The timezone of the agent (for the context window).")
 
+    # file related controls
+    max_files_open: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, doc="Maximum number of files that can be open at once for this agent."
+    )
+    per_file_view_window_char_limit: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, doc="The per-file view window character limit for this agent."
+    )
+
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="agents", lazy="raise")
     tool_exec_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
@@ -146,6 +155,15 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         lazy="selectin",
     )
 
+    def _get_per_file_view_window_char_limit(self) -> int:
+        """Get the per_file_view_window_char_limit, calculating defaults if None."""
+        if self.per_file_view_window_char_limit is not None:
+            return self.per_file_view_window_char_limit
+
+        context_window = self.llm_config.context_window if self.llm_config and self.llm_config.context_window else None
+        _, default_char_limit = calculate_file_defaults_based_on_context_window(context_window)
+        return default_char_limit
+
     def to_pydantic(self, include_relationships: Optional[Set[str]] = None) -> PydanticAgentState:
         """
         Converts the SQLAlchemy Agent model into its Pydantic counterpart.
@@ -191,6 +209,8 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
             "last_run_completion": self.last_run_completion,
             "last_run_duration_ms": self.last_run_duration_ms,
             "timezone": self.timezone,
+            "max_files_open": self.max_files_open,
+            "per_file_view_window_char_limit": self.per_file_view_window_char_limit,
             # optional field defaults
             "tags": [],
             "tools": [],
@@ -208,7 +228,12 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
             "sources": lambda: [s.to_pydantic() for s in self.sources],
             "memory": lambda: Memory(
                 blocks=[b.to_pydantic() for b in self.core_memory],
-                file_blocks=[block for b in self.file_agents if (block := b.to_pydantic_block()) is not None],
+                file_blocks=[
+                    block
+                    for b in self.file_agents
+                    if (block := b.to_pydantic_block(per_file_view_window_char_limit=self._get_per_file_view_window_char_limit()))
+                    is not None
+                ],
                 prompt_template=get_prompt_template_for_agent_type(self.agent_type),
             ),
             "identity_ids": lambda: [i.id for i in self.identities],
@@ -271,6 +296,8 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
             "response_format": self.response_format,
             "last_run_completion": self.last_run_completion,
             "last_run_duration_ms": self.last_run_duration_ms,
+            "max_files_open": self.max_files_open,
+            "per_file_view_window_char_limit": self.per_file_view_window_char_limit,
         }
         optional_fields = {
             "tags": [],
@@ -314,7 +341,11 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         state["sources"] = [s.to_pydantic() for s in sources]
         state["memory"] = Memory(
             blocks=[m.to_pydantic() for m in memory],
-            file_blocks=[block for b in file_agents if (block := b.to_pydantic_block()) is not None],
+            file_blocks=[
+                block
+                for b in file_agents
+                if (block := b.to_pydantic_block(per_file_view_window_char_limit=self._get_per_file_view_window_char_limit())) is not None
+            ],
             prompt_template=get_prompt_template_for_agent_type(self.agent_type),
         )
         state["identity_ids"] = [i.id for i in identities]

letta/orm/files_agents.py

@@ -5,10 +5,10 @@ from typing import TYPE_CHECKING, Optional
 from sqlalchemy import Boolean, DateTime, ForeignKey, Index, String, Text, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.constants import CORE_MEMORY_SOURCE_CHAR_LIMIT, FILE_IS_TRUNCATED_WARNING
+from letta.constants import FILE_IS_TRUNCATED_WARNING
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.block import Block as PydanticBlock
+from letta.schemas.block import FileBlock as PydanticFileBlock
 from letta.schemas.file import FileAgent as PydanticFileAgent
 
 if TYPE_CHECKING:
@@ -59,7 +59,7 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         String,
         ForeignKey("sources.id", ondelete="CASCADE"),
         nullable=False,
-        doc="ID of the source (denormalized from files.source_id)",
+        doc="ID of the source",
     )
 
     file_name: Mapped[str] = mapped_column(
@@ -86,19 +86,22 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
     )
 
     # TODO: This is temporary as we figure out if we want FileBlock as a first class citizen
-    def to_pydantic_block(self) -> PydanticBlock:
+    def to_pydantic_block(self, per_file_view_window_char_limit: int) -> PydanticFileBlock:
         visible_content = self.visible_content if self.visible_content and self.is_open else ""
 
         # Truncate content and add warnings here when converting from FileAgent to Block
-        if len(visible_content) > CORE_MEMORY_SOURCE_CHAR_LIMIT:
+        if len(visible_content) > per_file_view_window_char_limit:
             truncated_warning = f"...[TRUNCATED]\n{FILE_IS_TRUNCATED_WARNING}"
-            visible_content = visible_content[: CORE_MEMORY_SOURCE_CHAR_LIMIT - len(truncated_warning)]
+            visible_content = visible_content[: per_file_view_window_char_limit - len(truncated_warning)]
             visible_content += truncated_warning
 
-        return PydanticBlock(
+        return PydanticFileBlock(
             value=visible_content,
-            label=self.file_name,  # use denormalized file_name instead of self.file.file_name
+            label=self.file_name,
             read_only=True,
-            metadata={"source_id": self.source_id},  # use denormalized source_id
-            limit=CORE_MEMORY_SOURCE_CHAR_LIMIT,
+            file_id=self.file_id,
+            source_id=self.source_id,
+            is_open=self.is_open,
+            last_accessed_at=self.last_accessed_at,
+            limit=per_file_view_window_char_limit,
         )

letta/orm/mixins.py

@@ -62,3 +62,11 @@ class SandboxConfigMixin(Base):
     __abstract__ = True
 
     sandbox_config_id: Mapped[str] = mapped_column(String, ForeignKey("sandbox_configs.id"))
+
+
+class ProjectMixin(Base):
+    """Mixin for models that belong to a project."""
+
+    __abstract__ = True
+
+    project_id: Mapped[str] = mapped_column(String, nullable=True, doc="The associated project id.")

letta/orm/prompt.py

@@ -0,0 +1,13 @@
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.mixins import ProjectMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.prompt import Prompt as PydanticPrompt
+
+
+class Prompt(SqlalchemyBase, ProjectMixin):
+    __pydantic_model__ = PydanticPrompt
+    __tablename__ = "prompts"
+
+    id: Mapped[str] = mapped_column(primary_key=True, doc="Unique passage identifier")
+    prompt: Mapped[str] = mapped_column(doc="The string contents of the prompt.")