letta-nightly 0.6.11.dev20250120212046__py3-none-any.whl → 0.6.12.dev20250120222244__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.11"
+__version__ = "0.6.12"
 
 
 # import clients

letta/client/streaming.py

@@ -7,7 +7,7 @@ from httpx_sse import SSEError, connect_sse
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
 from letta.errors import LLMError
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import ReasoningMessage, ToolCallMessage, ToolReturnMessage
+from letta.schemas.letta_message import AssistantMessage, ReasoningMessage, ToolCallMessage, ToolReturnMessage
 from letta.schemas.letta_response import LettaStreamingResponse
 from letta.schemas.usage import LettaUsageStatistics
 
@@ -50,6 +50,8 @@ def _sse_post(url: str, data: dict, headers: dict) -> Generator[LettaStreamingRe
                         chunk_data = json.loads(sse.data)
                         if "reasoning" in chunk_data:
                             yield ReasoningMessage(**chunk_data)
+                        elif "assistant_message" in chunk_data:
+                            yield AssistantMessage(**chunk_data)
                         elif "tool_call" in chunk_data:
                             yield ToolCallMessage(**chunk_data)
                         elif "tool_return" in chunk_data:

letta/server/rest_api/app.py

@@ -290,8 +290,8 @@ def start_server(
         server_logger.addHandler(stream_handler)
 
     if (os.getenv("LOCAL_HTTPS") == "true") or "--localhttps" in sys.argv:
-        print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
-        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
+        print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
         uvicorn.run(
             app,
             host=host or "localhost",
@@ -300,8 +300,8 @@ def start_server(
             ssl_certfile="certs/localhost.pem",
         )
     else:
-        print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
-        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
+        print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard\n")
         uvicorn.run(
             app,
             host=host or "localhost",

letta/server/rest_api/interface.py

@@ -264,6 +264,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self,
         multi_step=True,
         # Related to if we want to try and pass back the AssistantMessage as a special case function
+        use_assistant_message=False,
         assistant_message_tool_name=DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg=DEFAULT_MESSAGE_TOOL_KWARG,
         # Related to if we expect inner_thoughts to be in the kwargs
@@ -295,9 +296,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # self.multi_step_gen_indicator = MessageStreamStatus.done_generation
 
         # Support for AssistantMessage
-        self.use_assistant_message = False  # TODO: Remove this
+        self.use_assistant_message = use_assistant_message  # TODO: Remove this (actually? @charles)
         self.assistant_message_tool_name = assistant_message_tool_name
         self.assistant_message_tool_kwarg = assistant_message_tool_kwarg
+        self.prev_assistant_message_id = None  # Used to skip tool call response receipts for `send_message`
 
         # Support for inner_thoughts_in_kwargs
         self.inner_thoughts_in_kwargs = inner_thoughts_in_kwargs
@@ -308,6 +310,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.function_name_buffer = None
         self.function_args_buffer = None
         self.function_id_buffer = None
+        # A buffer used to store the last flushed function name
+        self.last_flushed_function_name = None
 
         # extra prints
         self.debug = False
@@ -434,7 +438,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
             # TODO(charles) merge into logic for internal_monologue
             # special case for trapping `send_message`
-            if self.use_assistant_message and tool_call.function:
+            # if self.use_assistant_message and tool_call.function:
+            if not self.inner_thoughts_in_kwargs and self.use_assistant_message and tool_call.function:
                 if self.inner_thoughts_in_kwargs:
                     raise NotImplementedError("inner_thoughts_in_kwargs with use_assistant_message not yet supported")
 
@@ -535,15 +540,28 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         #       however the frontend may expect name first, then args, so to be
                         #       safe we'll output name first in a separate chunk
                         if self.function_name_buffer:
-                            processed_chunk = ToolCallMessage(
-                                id=message_id,
-                                date=message_date,
-                                tool_call=ToolCallDelta(
-                                    name=self.function_name_buffer,
-                                    arguments=None,
-                                    tool_call_id=self.function_id_buffer,
-                                ),
-                            )
+
+                            # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                            if self.use_assistant_message and self.function_name_buffer == self.assistant_message_tool_name:
+                                processed_chunk = None
+
+                                # Store the ID of the tool call so allow skipping the corresponding response
+                                if self.function_id_buffer:
+                                    self.prev_assistant_message_id = self.function_id_buffer
+
+                            else:
+                                processed_chunk = ToolCallMessage(
+                                    id=message_id,
+                                    date=message_date,
+                                    tool_call=ToolCallDelta(
+                                        name=self.function_name_buffer,
+                                        arguments=None,
+                                        tool_call_id=self.function_id_buffer,
+                                    ),
+                                )
+
+                            # Record what the last function name we flushed was
+                            self.last_flushed_function_name = self.function_name_buffer
                             # Clear the buffer
                             self.function_name_buffer = None
                             self.function_id_buffer = None
@@ -559,35 +577,94 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # If there was nothing in the name buffer, we can proceed to
                         # output the arguments chunk as a ToolCallMessage
                         else:
-                            # There may be a buffer from a previous chunk, for example
-                            # if the previous chunk had arguments but we needed to flush name
-                            if self.function_args_buffer:
-                                # In this case, we should release the buffer + new data at once
-                                combined_chunk = self.function_args_buffer + updates_main_json
-                                processed_chunk = ToolCallMessage(
-                                    id=message_id,
-                                    date=message_date,
-                                    tool_call=ToolCallDelta(
-                                        name=None,
-                                        arguments=combined_chunk,
-                                        tool_call_id=self.function_id_buffer,
-                                    ),
-                                )
-                                # clear buffer
-                                self.function_args_buffer = None
-                                self.function_id_buffer = None
+
+                            # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                            if self.use_assistant_message and (
+                                self.last_flushed_function_name is not None
+                                and self.last_flushed_function_name == self.assistant_message_tool_name
+                            ):
+                                # do an additional parse on the updates_main_json
+                                if self.function_args_buffer:
+
+                                    updates_main_json = self.function_args_buffer + updates_main_json
+                                    self.function_args_buffer = None
+
+                                    # Pretty gross hardcoding that assumes that if we're toggling into the keywords, we have the full prefix
+                                    match_str = '{"' + self.assistant_message_tool_kwarg + '":"'
+                                    if updates_main_json == match_str:
+                                        updates_main_json = None
+
+                                else:
+                                    # Some hardcoding to strip off the trailing "}"
+                                    if updates_main_json in ["}", '"}']:
+                                        updates_main_json = None
+                                    if updates_main_json and len(updates_main_json) > 0 and updates_main_json[-1:] == '"':
+                                        updates_main_json = updates_main_json[:-1]
+
+                                if not updates_main_json:
+                                    # early exit to turn into content mode
+                                    return None
+
+                                # There may be a buffer from a previous chunk, for example
+                                # if the previous chunk had arguments but we needed to flush name
+                                if self.function_args_buffer:
+                                    # In this case, we should release the buffer + new data at once
+                                    combined_chunk = self.function_args_buffer + updates_main_json
+                                    processed_chunk = AssistantMessage(
+                                        id=message_id,
+                                        date=message_date,
+                                        assistant_message=combined_chunk,
+                                    )
+                                    # Store the ID of the tool call so allow skipping the corresponding response
+                                    if self.function_id_buffer:
+                                        self.prev_assistant_message_id = self.function_id_buffer
+                                    # clear buffer
+                                    self.function_args_buffer = None
+                                    self.function_id_buffer = None
+
+                                else:
+                                    # If there's no buffer to clear, just output a new chunk with new data
+                                    processed_chunk = AssistantMessage(
+                                        id=message_id,
+                                        date=message_date,
+                                        assistant_message=updates_main_json,
+                                    )
+                                    # Store the ID of the tool call so allow skipping the corresponding response
+                                    if self.function_id_buffer:
+                                        self.prev_assistant_message_id = self.function_id_buffer
+                                    # clear buffers
+                                    self.function_id_buffer = None
                             else:
-                                # If there's no buffer to clear, just output a new chunk with new data
-                                processed_chunk = ToolCallMessage(
-                                    id=message_id,
-                                    date=message_date,
-                                    tool_call=ToolCallDelta(
-                                        name=None,
-                                        arguments=updates_main_json,
-                                        tool_call_id=self.function_id_buffer,
-                                    ),
-                                )
-                                self.function_id_buffer = None
+
+                                # There may be a buffer from a previous chunk, for example
+                                # if the previous chunk had arguments but we needed to flush name
+                                if self.function_args_buffer:
+                                    # In this case, we should release the buffer + new data at once
+                                    combined_chunk = self.function_args_buffer + updates_main_json
+                                    processed_chunk = ToolCallMessage(
+                                        id=message_id,
+                                        date=message_date,
+                                        tool_call=ToolCallDelta(
+                                            name=None,
+                                            arguments=combined_chunk,
+                                            tool_call_id=self.function_id_buffer,
+                                        ),
+                                    )
+                                    # clear buffer
+                                    self.function_args_buffer = None
+                                    self.function_id_buffer = None
+                                else:
+                                    # If there's no buffer to clear, just output a new chunk with new data
+                                    processed_chunk = ToolCallMessage(
+                                        id=message_id,
+                                        date=message_date,
+                                        tool_call=ToolCallDelta(
+                                            name=None,
+                                            arguments=updates_main_json,
+                                            tool_call_id=self.function_id_buffer,
+                                        ),
+                                    )
+                                    self.function_id_buffer = None
 
                         # # If there's something in the main_json buffer, we should add if to the arguments and release it together
                         # tool_call_delta = {}
@@ -906,6 +983,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             date=msg_obj.created_at,
                             assistant_message=func_args[self.assistant_message_tool_kwarg],
                         )
+                        # Store the ID of the tool call so allow skipping the corresponding response
+                        self.prev_assistant_message_id = function_call.id
                     else:
                         processed_chunk = ToolCallMessage(
                             id=msg_obj.id,
@@ -938,13 +1017,23 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             msg = msg.replace("Success: ", "")
             # new_message = {"function_return": msg, "status": "success"}
             assert msg_obj.tool_call_id is not None
-            new_message = ToolReturnMessage(
-                id=msg_obj.id,
-                date=msg_obj.created_at,
-                tool_return=msg,
-                status="success",
-                tool_call_id=msg_obj.tool_call_id,
-            )
+
+            print(f"YYY printing the function call - {msg_obj.tool_call_id} == {self.prev_assistant_message_id} ???")
+
+            # Skip this is use_assistant_message is on
+            if self.use_assistant_message and msg_obj.tool_call_id == self.prev_assistant_message_id:
+                # Wipe the cache
+                self.prev_assistant_message_id = None
+                # Skip this tool call receipt
+                return
+            else:
+                new_message = ToolReturnMessage(
+                    id=msg_obj.id,
+                    date=msg_obj.created_at,
+                    tool_return=msg,
+                    status="success",
+                    tool_call_id=msg_obj.tool_call_id,
+                )
 
         elif msg.startswith("Error: "):
             msg = msg.replace("Error: ", "", 1)

letta/server/server.py

@@ -1215,7 +1215,6 @@ class SyncServer(Server):
         stream_tokens: bool,
         # related to whether or not we return `LettaMessage`s or `Message`s
         chat_completion_mode: bool = False,
-        timestamp: Optional[datetime] = None,
         # Support for AssistantMessage
         use_assistant_message: bool = True,
         assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
@@ -1249,7 +1248,16 @@ class SyncServer(Server):
                 stream_tokens = False
 
             # Create a new interface per request
-            letta_agent.interface = StreamingServerInterface(use_assistant_message)
+            letta_agent.interface = StreamingServerInterface(
+                # multi_step=True,  # would we ever want to disable this?
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+                inner_thoughts_in_kwargs=(
+                    llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
+                ),
+                # inner_thoughts_kwarg=INNER_THOUGHTS_KWARG,
+            )
             streaming_interface = letta_agent.interface
             if not isinstance(streaming_interface, StreamingServerInterface):
                 raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
@@ -1263,13 +1271,14 @@ class SyncServer(Server):
             # streaming_interface.function_call_legacy_mode = stream
 
             # Allow AssistantMessage is desired by client
-            streaming_interface.assistant_message_tool_name = assistant_message_tool_name
-            streaming_interface.assistant_message_tool_kwarg = assistant_message_tool_kwarg
+            # streaming_interface.use_assistant_message = use_assistant_message
+            # streaming_interface.assistant_message_tool_name = assistant_message_tool_name
+            # streaming_interface.assistant_message_tool_kwarg = assistant_message_tool_kwarg
 
             # Related to JSON buffer reader
-            streaming_interface.inner_thoughts_in_kwargs = (
-                llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
-            )
+            # streaming_interface.inner_thoughts_in_kwargs = (
+            #     llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
+            # )
 
             # Offload the synchronous message_func to a separate thread
             streaming_interface.stream_start()

letta/streaming_utils.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Tuple
 
 from letta.constants import DEFAULT_MESSAGE_TOOL_KWARG
 
@@ -48,7 +48,7 @@ class JSONInnerThoughtsExtractor:
         self.hold_main_json = wait_for_first_key
         self.main_json_held_buffer = ""
 
-    def process_fragment(self, fragment):
+    def process_fragment(self, fragment: str) -> Tuple[str, str]:
         updates_main_json = ""
         updates_inner_thoughts = ""
         i = 0
@@ -263,8 +263,10 @@ class FunctionArgumentsStreamHandler:
             self.key_buffer = ""
             self.accumulating = True
             return None
+
         if chunk.strip() == "}":
             self.in_message = False
             self.message_started = False
             return None
+
         return None

{letta_nightly-0.6.11.dev20250120212046.dist-info → letta_nightly-0.6.12.dev20250120222244.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.11.dev20250120212046
+Version: 0.6.12.dev20250120222244
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.11.dev20250120212046.dist-info → letta_nightly-0.6.12.dev20250120222244.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=QaqMJBz4atxaXsgFGXhOht6gYc1g_HKntbHwsiwep3s,993
+letta/__init__.py,sha256=hzPeIYFlPTm3BdvaQW2D0Bu22kxEQdlkwfwDxyYtbJk,993
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=m4g4gbx4Y0SFPsGzNi6lmkwVSWPfvh2bYoQTKf1CL6A,57854
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
@@ -9,7 +9,7 @@ letta/cli/cli_config.py,sha256=I5J8D0OpsDDXCTOWFqjmxQuZCGrC1oCuNbVkrKwg4VM,8544
 letta/cli/cli_load.py,sha256=xFw-CuzjChcIptaqQ1XpDROENt0JSjyPeiQ0nmEeO1k,2706
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/client/client.py,sha256=EPLzfx_05J4ihIJtKwQ5rI_ncPxeK9-zLNyYaQ-ubg4,135712
-letta/client/streaming.py,sha256=Hz2j_hQZG2g7uhucjx2p3ybf2qjPT-vmIGCHGo87iCQ,4677
+letta/client/streaming.py,sha256=mWyMMCJeYf0aGcX_-9ZeiH3egh2Fl20Yjo1acaPO4nA,4824
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
 letta/constants.py,sha256=qkH98awgWUW1g9Qpb-IWqVULcLHH-lpblWeUZdLDzkY,7528
@@ -175,11 +175,11 @@ letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=Frxt6N7gbUs_BiPHZNJk0c8vjW6GzBfA0uEiN7dswPs,11850
+letta/server/rest_api/app.py,sha256=iFc5YNC2Wa5R0yWL3S1IrTMUHPWPWTHg5EkYbPw61ak,11850
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
-letta/server/rest_api/interface.py,sha256=XDEjDvuxfBbPpmhNnZk-Zd2eKAh1JgaaRkheEXH0VB4,45597
+letta/server/rest_api/interface.py,sha256=1p8Bt7uLNLJsKa-TnLXobiLfO91laclK-AiE-jbJr18,51494
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/assistants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -203,7 +203,7 @@ letta/server/rest_api/routers/v1/tools.py,sha256=rGw3hDUFYmY_kmJw5hsQWnBOWQqJFdf
 letta/server/rest_api/routers/v1/users.py,sha256=EBQe9IfCG3kzHpKmotz4yVGZioXz3SCSRy5yEhJK8hU,2293
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=dsjkZzgo9Rk3fjUf1ajjiiql1eeO5DAzmXprttI7bJU,3993
-letta/server/server.py,sha256=fhgtAieokRiX9aS18n_6FgPJOzJoFpLGNXRRyjz6bc8,57054
+letta/server/server.py,sha256=_Ubvl4CVQAh4BBKNzCnGHD47de2h6vuP2SvSnMZtA8U,57622
 letta/server/startup.sh,sha256=722uKJWB2C4q3vjn39De2zzPacaZNw_1fN1SpLGjKIo,1569
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -234,11 +234,11 @@ letta/services/tool_manager.py,sha256=CdI6aYQZr2Ar9-iDSMnjMcLIh8n8y_gkKte6FnUy9u
 letta/services/user_manager.py,sha256=oqLF9C4mGbN0TaGj7wMpb2RH2bUg6OJJcdyaWv370rQ,4272
 letta/settings.py,sha256=LJAMa0APYBPn9oFtpAGotH10drrzaoFGL88RFoc8QTI,4733
 letta/streaming_interface.py,sha256=lo2VAQRUJOdWTijwnXuKOC9uejqr2siUAEmZiQUXkj8,15710
-letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
+letta/streaming_utils.py,sha256=pJExJe6OgWDyRgzxbsSuT5JrVsXNlZP4hrT4Xu_z3Po,11778
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=FQgWuYF0CTCIyH41rVy_rD5_ATPIlBZ24ovBtf3T1tI,33291
-letta_nightly-0.6.11.dev20250120212046.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.11.dev20250120212046.dist-info/METADATA,sha256=Z21zU_CpTlyI4NA1xkzTaSJLfRn7P2gMWF45VYhB1pY,21836
-letta_nightly-0.6.11.dev20250120212046.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.11.dev20250120212046.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.11.dev20250120212046.dist-info/RECORD,,
+letta_nightly-0.6.12.dev20250120222244.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.12.dev20250120222244.dist-info/METADATA,sha256=TCGBysenArOWc2TOkQ7PkfQnCd5v6NCM0MetiKt1-Jw,21836
+letta_nightly-0.6.12.dev20250120222244.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.12.dev20250120222244.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.12.dev20250120222244.dist-info/RECORD,,