letta-client 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

letta_client/agents/client.py

@@ -5,11 +5,11 @@ from ..core.client_wrapper import SyncClientWrapper
 from .context.client import ContextClient
 from .tools.client import ToolsClient
 from .sources.client import SourcesClient
-from .core_memory.client import CoreMemoryClient
-from .archival_memory.client import ArchivalMemoryClient
 from .messages.client import MessagesClient
 from .templates.client import TemplatesClient
 from .memory_variables.client import MemoryVariablesClient
+from .core_memory.client import CoreMemoryClient
+from .archival_memory.client import ArchivalMemoryClient
 from ..core.request_options import RequestOptions
 from ..types.agent_state import AgentState
 from ..core.unchecked_base_model import construct_type
@@ -26,17 +26,20 @@ from ..types.message_create import MessageCreate
 from ..core.serialization import convert_and_respect_annotation_metadata
 from ..core.jsonable_encoder import jsonable_encoder
 from .types.update_agent_tool_rules_item import UpdateAgentToolRulesItem
+from ..types.memory import Memory
+from ..types.block import Block
+from ..types.passage import Passage
 from .types.agents_search_request_search_item import AgentsSearchRequestSearchItem
 from .types.agents_search_request_combinator import AgentsSearchRequestCombinator
 from ..core.client_wrapper import AsyncClientWrapper
 from .context.client import AsyncContextClient
 from .tools.client import AsyncToolsClient
 from .sources.client import AsyncSourcesClient
-from .core_memory.client import AsyncCoreMemoryClient
-from .archival_memory.client import AsyncArchivalMemoryClient
 from .messages.client import AsyncMessagesClient
 from .templates.client import AsyncTemplatesClient
 from .memory_variables.client import AsyncMemoryVariablesClient
+from .core_memory.client import AsyncCoreMemoryClient
+from .archival_memory.client import AsyncArchivalMemoryClient
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -48,11 +51,11 @@ class AgentsClient:
         self.context = ContextClient(client_wrapper=self._client_wrapper)
         self.tools = ToolsClient(client_wrapper=self._client_wrapper)
         self.sources = SourcesClient(client_wrapper=self._client_wrapper)
-        self.core_memory = CoreMemoryClient(client_wrapper=self._client_wrapper)
-        self.archival_memory = ArchivalMemoryClient(client_wrapper=self._client_wrapper)
         self.messages = MessagesClient(client_wrapper=self._client_wrapper)
         self.templates = TemplatesClient(client_wrapper=self._client_wrapper)
         self.memory_variables = MemoryVariablesClient(client_wrapper=self._client_wrapper)
+        self.core_memory = CoreMemoryClient(client_wrapper=self._client_wrapper)
+        self.archival_memory = ArchivalMemoryClient(client_wrapper=self._client_wrapper)
 
     def list(
         self,
@@ -304,7 +307,7 @@ class AgentsClient:
                 "include_base_tools": include_base_tools,
                 "include_multi_agent_tools": include_multi_agent_tools,
                 "description": description,
-                "metadata_": metadata,
+                "metadata": metadata,
                 "model": model,
                 "embedding": embedding,
                 "context_window_limit": context_window_limit,
@@ -345,7 +348,7 @@ class AgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get(self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> AgentState:
+    def retrieve(self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> AgentState:
         """
         Get the state of the agent.
 
@@ -368,7 +371,7 @@ class AgentsClient:
         client = Letta(
             token="YOUR_TOKEN",
         )
-        client.agents.get(
+        client.agents.retrieve(
             agent_id="agent_id",
         )
         """
@@ -459,7 +462,7 @@ class AgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def update(
+    def modify(
         self,
         agent_id: str,
         *,
@@ -539,7 +542,7 @@ class AgentsClient:
         client = Letta(
             token="YOUR_TOKEN",
         )
-        client.agents.update(
+        client.agents.modify(
             agent_id="agent_id",
         )
         """
@@ -564,7 +567,7 @@ class AgentsClient:
                 ),
                 "message_ids": message_ids,
                 "description": description,
-                "metadata_": metadata,
+                "metadata": metadata,
                 "tool_exec_environment_variables": tool_exec_environment_variables,
             },
             headers={
@@ -597,29 +600,23 @@ class AgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def reset_messages(
-        self,
-        agent_id: str,
-        *,
-        add_default_initial_messages: typing.Optional[bool] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AgentState:
+    def retrieve_agent_memory(
+        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Memory:
         """
-        Resets the messages for an agent
+        Retrieve the memory state of a specific agent.
+        This endpoint fetches the current memory state of the agent identified by the user ID and agent ID.
 
         Parameters
         ----------
         agent_id : str
 
-        add_default_initial_messages : typing.Optional[bool]
-            If true, adds the default initial messages after resetting.
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AgentState
+        Memory
             Successful Response
 
         Examples
@@ -629,24 +626,21 @@ class AgentsClient:
         client = Letta(
             token="YOUR_TOKEN",
         )
-        client.agents.reset_messages(
+        client.agents.retrieve_agent_memory(
             agent_id="agent_id",
         )
         """
         _response = self._client_wrapper.httpx_client.request(
-            f"v1/agents/{jsonable_encoder(agent_id)}/reset-messages",
-            method="PATCH",
-            params={
-                "add_default_initial_messages": add_default_initial_messages,
-            },
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory",
+            method="GET",
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    AgentState,
+                    Memory,
                     construct_type(
-                        type_=AgentState,  # type: ignore
+                        type_=Memory,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -665,39 +659,25 @@ class AgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def search(
-        self,
-        *,
-        search: typing.Optional[typing.Sequence[AgentsSearchRequestSearchItem]] = OMIT,
-        project_id: typing.Optional[str] = OMIT,
-        combinator: typing.Optional[AgentsSearchRequestCombinator] = OMIT,
-        limit: typing.Optional[float] = OMIT,
-        offset: typing.Optional[float] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> None:
+    def retrieve_core_memory_block(
+        self, agent_id: str, block_label: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Block:
         """
-        <Note>This endpoint is only available on Letta Cloud.</Note>
-
-        Search deployed agents.
+        Retrieve a memory block from an agent.
 
         Parameters
         ----------
-        search : typing.Optional[typing.Sequence[AgentsSearchRequestSearchItem]]
-
-        project_id : typing.Optional[str]
-
-        combinator : typing.Optional[AgentsSearchRequestCombinator]
-
-        limit : typing.Optional[float]
+        agent_id : str
 
-        offset : typing.Optional[float]
+        block_label : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        None
+        Block
+            Successful Response
 
         Examples
         --------
@@ -706,126 +686,183 @@ class AgentsClient:
         client = Letta(
             token="YOUR_TOKEN",
         )
-        client.agents.search()
+        client.agents.retrieve_core_memory_block(
+            agent_id="agent_id",
+            block_label="block_label",
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "v1/agents/search",
-            method="POST",
-            json={
-                "search": convert_and_respect_annotation_metadata(
-                    object_=search, annotation=typing.Sequence[AgentsSearchRequestSearchItem], direction="write"
-                ),
-                "project_id": project_id,
-                "combinator": combinator,
-                "limit": limit,
-                "offset": offset,
-            },
-            headers={
-                "content-type": "application/json",
-            },
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/{jsonable_encoder(block_label)}",
+            method="GET",
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
-                return
+                return typing.cast(
+                    Block,
+                    construct_type(
+                        type_=Block,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-
-class AsyncAgentsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
-        self.context = AsyncContextClient(client_wrapper=self._client_wrapper)
-        self.tools = AsyncToolsClient(client_wrapper=self._client_wrapper)
-        self.sources = AsyncSourcesClient(client_wrapper=self._client_wrapper)
-        self.core_memory = AsyncCoreMemoryClient(client_wrapper=self._client_wrapper)
-        self.archival_memory = AsyncArchivalMemoryClient(client_wrapper=self._client_wrapper)
-        self.messages = AsyncMessagesClient(client_wrapper=self._client_wrapper)
-        self.templates = AsyncTemplatesClient(client_wrapper=self._client_wrapper)
-        self.memory_variables = AsyncMemoryVariablesClient(client_wrapper=self._client_wrapper)
-
-    async def list(
+    def modify_core_memory_block(
         self,
+        agent_id: str,
+        block_label: str,
         *,
-        name: typing.Optional[str] = None,
-        tags: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
-        match_all_tags: typing.Optional[bool] = None,
-        cursor: typing.Optional[str] = None,
-        limit: typing.Optional[int] = None,
-        query_text: typing.Optional[str] = None,
+        value: typing.Optional[str] = OMIT,
+        limit: typing.Optional[int] = OMIT,
+        name: typing.Optional[str] = OMIT,
+        is_template: typing.Optional[bool] = OMIT,
+        label: typing.Optional[str] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> typing.List[AgentState]:
+    ) -> Block:
         """
-        List all agents associated with a given user.
-        This endpoint retrieves a list of all agents and their configurations associated with the specified user ID.
+        Updates a memory block of an agent.
 
         Parameters
         ----------
-        name : typing.Optional[str]
-            Name of the agent
-
-        tags : typing.Optional[typing.Union[str, typing.Sequence[str]]]
-            List of tags to filter agents by
+        agent_id : str
 
-        match_all_tags : typing.Optional[bool]
-            If True, only returns agents that match ALL given tags. Otherwise, return agents that have ANY of the passed in tags.
+        block_label : str
 
-        cursor : typing.Optional[str]
-            Cursor for pagination
+        value : typing.Optional[str]
+            Value of the block.
 
         limit : typing.Optional[int]
-            Limit for pagination
+            Character limit of the block.
 
-        query_text : typing.Optional[str]
-            Search agents by name
+        name : typing.Optional[str]
+            Name of the block if it is a template.
+
+        is_template : typing.Optional[bool]
+            Whether the block is a template (e.g. saved human/persona options).
+
+        label : typing.Optional[str]
+            Label of the block (e.g. 'human', 'persona') in the context window.
+
+        description : typing.Optional[str]
+            Description of the block.
+
+        metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            Metadata of the block.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        typing.List[AgentState]
+        Block
             Successful Response
 
         Examples
         --------
-        import asyncio
-
-        from letta_client import AsyncLetta
+        from letta_client import Letta
 
-        client = AsyncLetta(
+        client = Letta(
             token="YOUR_TOKEN",
         )
+        client.agents.modify_core_memory_block(
+            agent_id="agent_id",
+            block_label="block_label",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/{jsonable_encoder(block_label)}",
+            method="PATCH",
+            json={
+                "value": value,
+                "limit": limit,
+                "name": name,
+                "is_template": is_template,
+                "label": label,
+                "description": description,
+                "metadata": metadata,
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Block,
+                    construct_type(
+                        type_=Block,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def list_core_memory_blocks(
+        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[Block]:
+        """
+        Retrieve the memory blocks of a specific agent.
 
-        async def main() -> None:
-            await client.agents.list()
+        Parameters
+        ----------
+        agent_id : str
 
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
 
-        asyncio.run(main())
+        Returns
+        -------
+        typing.List[Block]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.list_core_memory_blocks(
+            agent_id="agent_id",
+        )
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/agents/",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks",
             method="GET",
-            params={
-                "name": name,
-                "tags": tags,
-                "match_all_tags": match_all_tags,
-                "cursor": cursor,
-                "limit": limit,
-                "query_text": query_text,
-            },
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    typing.List[AgentState],
+                    typing.List[Block],
                     construct_type(
-                        type_=typing.List[AgentState],  # type: ignore
+                        type_=typing.List[Block],  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -844,126 +881,1332 @@ class AsyncAgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def create(
-        self,
-        *,
-        name: typing.Optional[str] = OMIT,
-        memory_blocks: typing.Optional[typing.Sequence[CreateBlock]] = OMIT,
-        tools: typing.Optional[typing.Sequence[str]] = OMIT,
-        tool_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        source_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        block_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        tool_rules: typing.Optional[typing.Sequence[CreateAgentRequestToolRulesItem]] = OMIT,
-        tags: typing.Optional[typing.Sequence[str]] = OMIT,
-        system: typing.Optional[str] = OMIT,
-        agent_type: typing.Optional[AgentType] = OMIT,
-        llm_config: typing.Optional[LlmConfig] = OMIT,
-        embedding_config: typing.Optional[EmbeddingConfig] = OMIT,
-        initial_message_sequence: typing.Optional[typing.Sequence[MessageCreate]] = OMIT,
-        include_base_tools: typing.Optional[bool] = OMIT,
-        include_multi_agent_tools: typing.Optional[bool] = OMIT,
-        description: typing.Optional[str] = OMIT,
-        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
-        model: typing.Optional[str] = OMIT,
-        embedding: typing.Optional[str] = OMIT,
-        context_window_limit: typing.Optional[int] = OMIT,
-        embedding_chunk_size: typing.Optional[int] = OMIT,
-        from_template: typing.Optional[str] = OMIT,
-        template: typing.Optional[bool] = OMIT,
-        project: typing.Optional[str] = OMIT,
-        tool_exec_environment_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
-        memory_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
+    def attach_core_memory_block(
+        self, agent_id: str, block_id: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> AgentState:
         """
-        Create a new agent with the specified configuration.
+        Attach a block to an agent.
 
         Parameters
         ----------
-        name : typing.Optional[str]
-            The name of the agent.
-
-        memory_blocks : typing.Optional[typing.Sequence[CreateBlock]]
-            The blocks to create in the agent's in-context memory.
+        agent_id : str
 
-        tools : typing.Optional[typing.Sequence[str]]
-            The tools used by the agent.
+        block_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.attach_core_memory_block(
+            agent_id="agent_id",
+            block_id="block_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/attach/{jsonable_encoder(block_id)}",
+            method="PATCH",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def detach_core_memory_block(
+        self, agent_id: str, block_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AgentState:
+        """
+        Detach a block from an agent.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        block_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.detach_core_memory_block(
+            agent_id="agent_id",
+            block_id="block_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/detach/{jsonable_encoder(block_id)}",
+            method="PATCH",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def list_archival_memory(
+        self,
+        agent_id: str,
+        *,
+        after: typing.Optional[int] = None,
+        before: typing.Optional[int] = None,
+        limit: typing.Optional[int] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.List[Passage]:
+        """
+        Retrieve the memories in an agent's archival memory store (paginated query).
+
+        Parameters
+        ----------
+        agent_id : str
+
+        after : typing.Optional[int]
+            Unique ID of the memory to start the query range at.
+
+        before : typing.Optional[int]
+            Unique ID of the memory to end the query range at.
+
+        limit : typing.Optional[int]
+            How many results to include in the response.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[Passage]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.list_archival_memory(
+            agent_id="agent_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory",
+            method="GET",
+            params={
+                "after": after,
+                "before": before,
+                "limit": limit,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[Passage],
+                    construct_type(
+                        type_=typing.List[Passage],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def create_archival_memory(
+        self, agent_id: str, *, text: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[Passage]:
+        """
+        Insert a memory into an agent's archival memory store.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        text : str
+            Text to write to archival memory.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[Passage]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.create_archival_memory(
+            agent_id="agent_id",
+            text="text",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory",
+            method="POST",
+            json={
+                "text": text,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[Passage],
+                    construct_type(
+                        type_=typing.List[Passage],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def delete_archival_memory(
+        self, agent_id: str, memory_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Optional[typing.Any]:
+        """
+        Delete a memory from an agent's archival memory store.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        memory_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Optional[typing.Any]
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.delete_archival_memory(
+            agent_id="agent_id",
+            memory_id="memory_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory/{jsonable_encoder(memory_id)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.Optional[typing.Any],
+                    construct_type(
+                        type_=typing.Optional[typing.Any],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def reset_messages(
+        self,
+        agent_id: str,
+        *,
+        add_default_initial_messages: typing.Optional[bool] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AgentState:
+        """
+        Resets the messages for an agent
+
+        Parameters
+        ----------
+        agent_id : str
+
+        add_default_initial_messages : typing.Optional[bool]
+            If true, adds the default initial messages after resetting.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.reset_messages(
+            agent_id="agent_id",
+        )
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/reset-messages",
+            method="PATCH",
+            params={
+                "add_default_initial_messages": add_default_initial_messages,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def search(
+        self,
+        *,
+        search: typing.Optional[typing.Sequence[AgentsSearchRequestSearchItem]] = OMIT,
+        project_id: typing.Optional[str] = OMIT,
+        combinator: typing.Optional[AgentsSearchRequestCombinator] = OMIT,
+        limit: typing.Optional[float] = OMIT,
+        offset: typing.Optional[float] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> None:
+        """
+        <Note>This endpoint is only available on Letta Cloud.</Note>
+
+        Search deployed agents.
+
+        Parameters
+        ----------
+        search : typing.Optional[typing.Sequence[AgentsSearchRequestSearchItem]]
+
+        project_id : typing.Optional[str]
+
+        combinator : typing.Optional[AgentsSearchRequestCombinator]
+
+        limit : typing.Optional[float]
+
+        offset : typing.Optional[float]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        from letta_client import Letta
+
+        client = Letta(
+            token="YOUR_TOKEN",
+        )
+        client.agents.search()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/agents/search",
+            method="POST",
+            json={
+                "search": convert_and_respect_annotation_metadata(
+                    object_=search, annotation=typing.Sequence[AgentsSearchRequestSearchItem], direction="write"
+                ),
+                "project_id": project_id,
+                "combinator": combinator,
+                "limit": limit,
+                "offset": offset,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncAgentsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+        self.context = AsyncContextClient(client_wrapper=self._client_wrapper)
+        self.tools = AsyncToolsClient(client_wrapper=self._client_wrapper)
+        self.sources = AsyncSourcesClient(client_wrapper=self._client_wrapper)
+        self.messages = AsyncMessagesClient(client_wrapper=self._client_wrapper)
+        self.templates = AsyncTemplatesClient(client_wrapper=self._client_wrapper)
+        self.memory_variables = AsyncMemoryVariablesClient(client_wrapper=self._client_wrapper)
+        self.core_memory = AsyncCoreMemoryClient(client_wrapper=self._client_wrapper)
+        self.archival_memory = AsyncArchivalMemoryClient(client_wrapper=self._client_wrapper)
+
+    async def list(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        tags: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        match_all_tags: typing.Optional[bool] = None,
+        cursor: typing.Optional[str] = None,
+        limit: typing.Optional[int] = None,
+        query_text: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.List[AgentState]:
+        """
+        List all agents associated with a given user.
+        This endpoint retrieves a list of all agents and their configurations associated with the specified user ID.
+
+        Parameters
+        ----------
+        name : typing.Optional[str]
+            Name of the agent
+
+        tags : typing.Optional[typing.Union[str, typing.Sequence[str]]]
+            List of tags to filter agents by
+
+        match_all_tags : typing.Optional[bool]
+            If True, only returns agents that match ALL given tags. Otherwise, return agents that have ANY of the passed in tags.
+
+        cursor : typing.Optional[str]
+            Cursor for pagination
+
+        limit : typing.Optional[int]
+            Limit for pagination
+
+        query_text : typing.Optional[str]
+            Search agents by name
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.List[AgentState]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.list()
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/agents/",
+            method="GET",
+            params={
+                "name": name,
+                "tags": tags,
+                "match_all_tags": match_all_tags,
+                "cursor": cursor,
+                "limit": limit,
+                "query_text": query_text,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[AgentState],
+                    construct_type(
+                        type_=typing.List[AgentState],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def create(
+        self,
+        *,
+        name: typing.Optional[str] = OMIT,
+        memory_blocks: typing.Optional[typing.Sequence[CreateBlock]] = OMIT,
+        tools: typing.Optional[typing.Sequence[str]] = OMIT,
+        tool_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        source_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        block_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        tool_rules: typing.Optional[typing.Sequence[CreateAgentRequestToolRulesItem]] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        system: typing.Optional[str] = OMIT,
+        agent_type: typing.Optional[AgentType] = OMIT,
+        llm_config: typing.Optional[LlmConfig] = OMIT,
+        embedding_config: typing.Optional[EmbeddingConfig] = OMIT,
+        initial_message_sequence: typing.Optional[typing.Sequence[MessageCreate]] = OMIT,
+        include_base_tools: typing.Optional[bool] = OMIT,
+        include_multi_agent_tools: typing.Optional[bool] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
+        model: typing.Optional[str] = OMIT,
+        embedding: typing.Optional[str] = OMIT,
+        context_window_limit: typing.Optional[int] = OMIT,
+        embedding_chunk_size: typing.Optional[int] = OMIT,
+        from_template: typing.Optional[str] = OMIT,
+        template: typing.Optional[bool] = OMIT,
+        project: typing.Optional[str] = OMIT,
+        tool_exec_environment_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
+        memory_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AgentState:
+        """
+        Create a new agent with the specified configuration.
+
+        Parameters
+        ----------
+        name : typing.Optional[str]
+            The name of the agent.
+
+        memory_blocks : typing.Optional[typing.Sequence[CreateBlock]]
+            The blocks to create in the agent's in-context memory.
+
+        tools : typing.Optional[typing.Sequence[str]]
+            The tools used by the agent.
+
+        tool_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the tools used by the agent.
+
+        source_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the sources used by the agent.
+
+        block_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the blocks used by the agent.
+
+        tool_rules : typing.Optional[typing.Sequence[CreateAgentRequestToolRulesItem]]
+            The tool rules governing the agent.
+
+        tags : typing.Optional[typing.Sequence[str]]
+            The tags associated with the agent.
+
+        system : typing.Optional[str]
+            The system prompt used by the agent.
+
+        agent_type : typing.Optional[AgentType]
+            The type of agent.
+
+        llm_config : typing.Optional[LlmConfig]
+            The LLM configuration used by the agent.
+
+        embedding_config : typing.Optional[EmbeddingConfig]
+            The embedding configuration used by the agent.
+
+        initial_message_sequence : typing.Optional[typing.Sequence[MessageCreate]]
+            The initial set of messages to put in the agent's in-context memory.
+
+        include_base_tools : typing.Optional[bool]
+            If true, attaches the Letta core tools (e.g. archival_memory and core_memory related functions).
+
+        include_multi_agent_tools : typing.Optional[bool]
+            If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent).
+
+        description : typing.Optional[str]
+            The description of the agent.
+
+        metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            The metadata of the agent.
+
+        model : typing.Optional[str]
+            The LLM configuration handle used by the agent, specified in the format provider/model-name, as an alternative to specifying llm_config.
+
+        embedding : typing.Optional[str]
+            The embedding configuration handle used by the agent, specified in the format provider/model-name.
+
+        context_window_limit : typing.Optional[int]
+            The context window limit used by the agent.
+
+        embedding_chunk_size : typing.Optional[int]
+            The embedding chunk size used by the agent.
+
+        from_template : typing.Optional[str]
+            The template id used to configure the agent
+
+        template : typing.Optional[bool]
+            Whether the agent is a template
+
+        project : typing.Optional[str]
+            The project slug that the agent will be associated with.
+
+        tool_exec_environment_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
+            The environment variables for tool execution specific to this agent.
+
+        memory_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
+            The variables that should be set for the agent.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.create()
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/agents/",
+            method="POST",
+            json={
+                "name": name,
+                "memory_blocks": convert_and_respect_annotation_metadata(
+                    object_=memory_blocks, annotation=typing.Sequence[CreateBlock], direction="write"
+                ),
+                "tools": tools,
+                "tool_ids": tool_ids,
+                "source_ids": source_ids,
+                "block_ids": block_ids,
+                "tool_rules": convert_and_respect_annotation_metadata(
+                    object_=tool_rules, annotation=typing.Sequence[CreateAgentRequestToolRulesItem], direction="write"
+                ),
+                "tags": tags,
+                "system": system,
+                "agent_type": agent_type,
+                "llm_config": convert_and_respect_annotation_metadata(
+                    object_=llm_config, annotation=LlmConfig, direction="write"
+                ),
+                "embedding_config": convert_and_respect_annotation_metadata(
+                    object_=embedding_config, annotation=EmbeddingConfig, direction="write"
+                ),
+                "initial_message_sequence": convert_and_respect_annotation_metadata(
+                    object_=initial_message_sequence, annotation=typing.Sequence[MessageCreate], direction="write"
+                ),
+                "include_base_tools": include_base_tools,
+                "include_multi_agent_tools": include_multi_agent_tools,
+                "description": description,
+                "metadata": metadata,
+                "model": model,
+                "embedding": embedding,
+                "context_window_limit": context_window_limit,
+                "embedding_chunk_size": embedding_chunk_size,
+                "from_template": from_template,
+                "template": template,
+                "project": project,
+                "tool_exec_environment_variables": tool_exec_environment_variables,
+                "memory_variables": memory_variables,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def retrieve(self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> AgentState:
+        """
+        Get the state of the agent.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.retrieve(
+                agent_id="agent_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def delete(
+        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Optional[typing.Any]:
+        """
+        Delete an agent.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Optional[typing.Any]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.delete(
+                agent_id="agent_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.Optional[typing.Any],
+                    construct_type(
+                        type_=typing.Optional[typing.Any],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def modify(
+        self,
+        agent_id: str,
+        *,
+        name: typing.Optional[str] = OMIT,
+        tool_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        source_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        block_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        system: typing.Optional[str] = OMIT,
+        tool_rules: typing.Optional[typing.Sequence[UpdateAgentToolRulesItem]] = OMIT,
+        llm_config: typing.Optional[LlmConfig] = OMIT,
+        embedding_config: typing.Optional[EmbeddingConfig] = OMIT,
+        message_ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
+        tool_exec_environment_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AgentState:
+        """
+        Update an existing agent
+
+        Parameters
+        ----------
+        agent_id : str
+
+        name : typing.Optional[str]
+            The name of the agent.
 
         tool_ids : typing.Optional[typing.Sequence[str]]
             The ids of the tools used by the agent.
 
-        source_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the sources used by the agent.
+        source_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the sources used by the agent.
+
+        block_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the blocks used by the agent.
+
+        tags : typing.Optional[typing.Sequence[str]]
+            The tags associated with the agent.
+
+        system : typing.Optional[str]
+            The system prompt used by the agent.
+
+        tool_rules : typing.Optional[typing.Sequence[UpdateAgentToolRulesItem]]
+            The tool rules governing the agent.
+
+        llm_config : typing.Optional[LlmConfig]
+            The LLM configuration used by the agent.
+
+        embedding_config : typing.Optional[EmbeddingConfig]
+            The embedding configuration used by the agent.
+
+        message_ids : typing.Optional[typing.Sequence[str]]
+            The ids of the messages in the agent's in-context memory.
+
+        description : typing.Optional[str]
+            The description of the agent.
+
+        metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
+            The metadata of the agent.
+
+        tool_exec_environment_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
+            The environment variables for tool execution specific to this agent.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AgentState
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.modify(
+                agent_id="agent_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}",
+            method="PATCH",
+            json={
+                "name": name,
+                "tool_ids": tool_ids,
+                "source_ids": source_ids,
+                "block_ids": block_ids,
+                "tags": tags,
+                "system": system,
+                "tool_rules": convert_and_respect_annotation_metadata(
+                    object_=tool_rules, annotation=typing.Sequence[UpdateAgentToolRulesItem], direction="write"
+                ),
+                "llm_config": convert_and_respect_annotation_metadata(
+                    object_=llm_config, annotation=LlmConfig, direction="write"
+                ),
+                "embedding_config": convert_and_respect_annotation_metadata(
+                    object_=embedding_config, annotation=EmbeddingConfig, direction="write"
+                ),
+                "message_ids": message_ids,
+                "description": description,
+                "metadata": metadata,
+                "tool_exec_environment_variables": tool_exec_environment_variables,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    AgentState,
+                    construct_type(
+                        type_=AgentState,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def retrieve_agent_memory(
+        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Memory:
+        """
+        Retrieve the memory state of a specific agent.
+        This endpoint fetches the current memory state of the agent identified by the user ID and agent ID.
 
-        block_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the blocks used by the agent.
+        Parameters
+        ----------
+        agent_id : str
 
-        tool_rules : typing.Optional[typing.Sequence[CreateAgentRequestToolRulesItem]]
-            The tool rules governing the agent.
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
 
-        tags : typing.Optional[typing.Sequence[str]]
-            The tags associated with the agent.
+        Returns
+        -------
+        Memory
+            Successful Response
 
-        system : typing.Optional[str]
-            The system prompt used by the agent.
+        Examples
+        --------
+        import asyncio
 
-        agent_type : typing.Optional[AgentType]
-            The type of agent.
+        from letta_client import AsyncLetta
 
-        llm_config : typing.Optional[LlmConfig]
-            The LLM configuration used by the agent.
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
 
-        embedding_config : typing.Optional[EmbeddingConfig]
-            The embedding configuration used by the agent.
 
-        initial_message_sequence : typing.Optional[typing.Sequence[MessageCreate]]
-            The initial set of messages to put in the agent's in-context memory.
+        async def main() -> None:
+            await client.agents.retrieve_agent_memory(
+                agent_id="agent_id",
+            )
 
-        include_base_tools : typing.Optional[bool]
-            If true, attaches the Letta core tools (e.g. archival_memory and core_memory related functions).
 
-        include_multi_agent_tools : typing.Optional[bool]
-            If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent).
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Memory,
+                    construct_type(
+                        type_=Memory,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def retrieve_core_memory_block(
+        self, agent_id: str, block_label: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> Block:
+        """
+        Retrieve a memory block from an agent.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        block_label : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Block
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.retrieve_core_memory_block(
+                agent_id="agent_id",
+                block_label="block_label",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/{jsonable_encoder(block_label)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Block,
+                    construct_type(
+                        type_=Block,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def modify_core_memory_block(
+        self,
+        agent_id: str,
+        block_label: str,
+        *,
+        value: typing.Optional[str] = OMIT,
+        limit: typing.Optional[int] = OMIT,
+        name: typing.Optional[str] = OMIT,
+        is_template: typing.Optional[bool] = OMIT,
+        label: typing.Optional[str] = OMIT,
+        description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Block:
+        """
+        Updates a memory block of an agent.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        block_label : str
+
+        value : typing.Optional[str]
+            Value of the block.
+
+        limit : typing.Optional[int]
+            Character limit of the block.
+
+        name : typing.Optional[str]
+            Name of the block if it is a template.
+
+        is_template : typing.Optional[bool]
+            Whether the block is a template (e.g. saved human/persona options).
+
+        label : typing.Optional[str]
+            Label of the block (e.g. 'human', 'persona') in the context window.
 
         description : typing.Optional[str]
-            The description of the agent.
+            Description of the block.
 
         metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            The metadata of the agent.
+            Metadata of the block.
 
-        model : typing.Optional[str]
-            The LLM configuration handle used by the agent, specified in the format provider/model-name, as an alternative to specifying llm_config.
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
 
-        embedding : typing.Optional[str]
-            The embedding configuration handle used by the agent, specified in the format provider/model-name.
+        Returns
+        -------
+        Block
+            Successful Response
 
-        context_window_limit : typing.Optional[int]
-            The context window limit used by the agent.
+        Examples
+        --------
+        import asyncio
 
-        embedding_chunk_size : typing.Optional[int]
-            The embedding chunk size used by the agent.
+        from letta_client import AsyncLetta
 
-        from_template : typing.Optional[str]
-            The template id used to configure the agent
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
 
-        template : typing.Optional[bool]
-            Whether the agent is a template
 
-        project : typing.Optional[str]
-            The project slug that the agent will be associated with.
+        async def main() -> None:
+            await client.agents.modify_core_memory_block(
+                agent_id="agent_id",
+                block_label="block_label",
+            )
 
-        tool_exec_environment_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
-            The environment variables for tool execution specific to this agent.
 
-        memory_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
-            The variables that should be set for the agent.
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/{jsonable_encoder(block_label)}",
+            method="PATCH",
+            json={
+                "value": value,
+                "limit": limit,
+                "name": name,
+                "is_template": is_template,
+                "label": label,
+                "description": description,
+                "metadata": metadata,
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    Block,
+                    construct_type(
+                        type_=Block,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def list_core_memory_blocks(
+        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[Block]:
+        """
+        Retrieve the memory blocks of a specific agent.
+
+        Parameters
+        ----------
+        agent_id : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AgentState
+        typing.List[Block]
             Successful Response
 
         Examples
@@ -978,64 +2221,24 @@ class AsyncAgentsClient:
 
 
         async def main() -> None:
-            await client.agents.create()
+            await client.agents.list_core_memory_blocks(
+                agent_id="agent_id",
+            )
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/agents/",
-            method="POST",
-            json={
-                "name": name,
-                "memory_blocks": convert_and_respect_annotation_metadata(
-                    object_=memory_blocks, annotation=typing.Sequence[CreateBlock], direction="write"
-                ),
-                "tools": tools,
-                "tool_ids": tool_ids,
-                "source_ids": source_ids,
-                "block_ids": block_ids,
-                "tool_rules": convert_and_respect_annotation_metadata(
-                    object_=tool_rules, annotation=typing.Sequence[CreateAgentRequestToolRulesItem], direction="write"
-                ),
-                "tags": tags,
-                "system": system,
-                "agent_type": agent_type,
-                "llm_config": convert_and_respect_annotation_metadata(
-                    object_=llm_config, annotation=LlmConfig, direction="write"
-                ),
-                "embedding_config": convert_and_respect_annotation_metadata(
-                    object_=embedding_config, annotation=EmbeddingConfig, direction="write"
-                ),
-                "initial_message_sequence": convert_and_respect_annotation_metadata(
-                    object_=initial_message_sequence, annotation=typing.Sequence[MessageCreate], direction="write"
-                ),
-                "include_base_tools": include_base_tools,
-                "include_multi_agent_tools": include_multi_agent_tools,
-                "description": description,
-                "metadata_": metadata,
-                "model": model,
-                "embedding": embedding,
-                "context_window_limit": context_window_limit,
-                "embedding_chunk_size": embedding_chunk_size,
-                "from_template": from_template,
-                "template": template,
-                "project": project,
-                "tool_exec_environment_variables": tool_exec_environment_variables,
-                "memory_variables": memory_variables,
-            },
-            headers={
-                "content-type": "application/json",
-            },
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks",
+            method="GET",
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    AgentState,
+                    typing.List[Block],
                     construct_type(
-                        type_=AgentState,  # type: ignore
+                        type_=typing.List[Block],  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1054,14 +2257,18 @@ class AsyncAgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def get(self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None) -> AgentState:
+    async def attach_core_memory_block(
+        self, agent_id: str, block_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AgentState:
         """
-        Get the state of the agent.
+        Attach a block to an agent.
 
         Parameters
         ----------
         agent_id : str
 
+        block_id : str
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -1082,16 +2289,17 @@ class AsyncAgentsClient:
 
 
         async def main() -> None:
-            await client.agents.get(
+            await client.agents.attach_core_memory_block(
                 agent_id="agent_id",
+                block_id="block_id",
             )
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/agents/{jsonable_encoder(agent_id)}",
-            method="GET",
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/attach/{jsonable_encoder(block_id)}",
+            method="PATCH",
             request_options=request_options,
         )
         try:
@@ -1118,22 +2326,24 @@ class AsyncAgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def delete(
-        self, agent_id: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> typing.Optional[typing.Any]:
+    async def detach_core_memory_block(
+        self, agent_id: str, block_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AgentState:
         """
-        Delete an agent.
+        Detach a block from an agent.
 
         Parameters
         ----------
         agent_id : str
 
+        block_id : str
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        typing.Optional[typing.Any]
+        AgentState
             Successful Response
 
         Examples
@@ -1148,24 +2358,25 @@ class AsyncAgentsClient:
 
 
         async def main() -> None:
-            await client.agents.delete(
+            await client.agents.detach_core_memory_block(
                 agent_id="agent_id",
+                block_id="block_id",
             )
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/agents/{jsonable_encoder(agent_id)}",
-            method="DELETE",
+            f"v1/agents/{jsonable_encoder(agent_id)}/core-memory/blocks/detach/{jsonable_encoder(block_id)}",
+            method="PATCH",
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    typing.Optional[typing.Any],
+                    AgentState,
                     construct_type(
-                        type_=typing.Optional[typing.Any],  # type: ignore
+                        type_=AgentState,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1184,77 +2395,111 @@ class AsyncAgentsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def update(
+    async def list_archival_memory(
         self,
         agent_id: str,
         *,
-        name: typing.Optional[str] = OMIT,
-        tool_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        source_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        block_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        tags: typing.Optional[typing.Sequence[str]] = OMIT,
-        system: typing.Optional[str] = OMIT,
-        tool_rules: typing.Optional[typing.Sequence[UpdateAgentToolRulesItem]] = OMIT,
-        llm_config: typing.Optional[LlmConfig] = OMIT,
-        embedding_config: typing.Optional[EmbeddingConfig] = OMIT,
-        message_ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        description: typing.Optional[str] = OMIT,
-        metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = OMIT,
-        tool_exec_environment_variables: typing.Optional[typing.Dict[str, typing.Optional[str]]] = OMIT,
+        after: typing.Optional[int] = None,
+        before: typing.Optional[int] = None,
+        limit: typing.Optional[int] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AgentState:
+    ) -> typing.List[Passage]:
         """
-        Update an existing agent
+        Retrieve the memories in an agent's archival memory store (paginated query).
 
         Parameters
         ----------
         agent_id : str
 
-        name : typing.Optional[str]
-            The name of the agent.
+        after : typing.Optional[int]
+            Unique ID of the memory to start the query range at.
 
-        tool_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the tools used by the agent.
+        before : typing.Optional[int]
+            Unique ID of the memory to end the query range at.
 
-        source_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the sources used by the agent.
+        limit : typing.Optional[int]
+            How many results to include in the response.
 
-        block_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the blocks used by the agent.
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
 
-        tags : typing.Optional[typing.Sequence[str]]
-            The tags associated with the agent.
+        Returns
+        -------
+        typing.List[Passage]
+            Successful Response
 
-        system : typing.Optional[str]
-            The system prompt used by the agent.
+        Examples
+        --------
+        import asyncio
 
-        tool_rules : typing.Optional[typing.Sequence[UpdateAgentToolRulesItem]]
-            The tool rules governing the agent.
+        from letta_client import AsyncLetta
 
-        llm_config : typing.Optional[LlmConfig]
-            The LLM configuration used by the agent.
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
 
-        embedding_config : typing.Optional[EmbeddingConfig]
-            The embedding configuration used by the agent.
 
-        message_ids : typing.Optional[typing.Sequence[str]]
-            The ids of the messages in the agent's in-context memory.
+        async def main() -> None:
+            await client.agents.list_archival_memory(
+                agent_id="agent_id",
+            )
 
-        description : typing.Optional[str]
-            The description of the agent.
 
-        metadata : typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]
-            The metadata of the agent.
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory",
+            method="GET",
+            params={
+                "after": after,
+                "before": before,
+                "limit": limit,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.List[Passage],
+                    construct_type(
+                        type_=typing.List[Passage],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
 
-        tool_exec_environment_variables : typing.Optional[typing.Dict[str, typing.Optional[str]]]
-            The environment variables for tool execution specific to this agent.
+    async def create_archival_memory(
+        self, agent_id: str, *, text: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.List[Passage]:
+        """
+        Insert a memory into an agent's archival memory store.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        text : str
+            Text to write to archival memory.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AgentState
+        typing.List[Passage]
             Successful Response
 
         Examples
@@ -1269,36 +2514,19 @@ class AsyncAgentsClient:
 
 
         async def main() -> None:
-            await client.agents.update(
+            await client.agents.create_archival_memory(
                 agent_id="agent_id",
+                text="text",
             )
 
 
         asyncio.run(main())
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/agents/{jsonable_encoder(agent_id)}",
-            method="PATCH",
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory",
+            method="POST",
             json={
-                "name": name,
-                "tool_ids": tool_ids,
-                "source_ids": source_ids,
-                "block_ids": block_ids,
-                "tags": tags,
-                "system": system,
-                "tool_rules": convert_and_respect_annotation_metadata(
-                    object_=tool_rules, annotation=typing.Sequence[UpdateAgentToolRulesItem], direction="write"
-                ),
-                "llm_config": convert_and_respect_annotation_metadata(
-                    object_=llm_config, annotation=LlmConfig, direction="write"
-                ),
-                "embedding_config": convert_and_respect_annotation_metadata(
-                    object_=embedding_config, annotation=EmbeddingConfig, direction="write"
-                ),
-                "message_ids": message_ids,
-                "description": description,
-                "metadata_": metadata,
-                "tool_exec_environment_variables": tool_exec_environment_variables,
+                "text": text,
             },
             headers={
                 "content-type": "application/json",
@@ -1309,9 +2537,78 @@ class AsyncAgentsClient:
         try:
             if 200 <= _response.status_code < 300:
                 return typing.cast(
-                    AgentState,
+                    typing.List[Passage],
                     construct_type(
-                        type_=AgentState,  # type: ignore
+                        type_=typing.List[Passage],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    typing.cast(
+                        HttpValidationError,
+                        construct_type(
+                            type_=HttpValidationError,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    )
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def delete_archival_memory(
+        self, agent_id: str, memory_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> typing.Optional[typing.Any]:
+        """
+        Delete a memory from an agent's archival memory store.
+
+        Parameters
+        ----------
+        agent_id : str
+
+        memory_id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Optional[typing.Any]
+            Successful Response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta
+
+        client = AsyncLetta(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.agents.delete_archival_memory(
+                agent_id="agent_id",
+                memory_id="memory_id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/agents/{jsonable_encoder(agent_id)}/archival-memory/{jsonable_encoder(memory_id)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return typing.cast(
+                    typing.Optional[typing.Any],
+                    construct_type(
+                        type_=typing.Optional[typing.Any],  # type: ignore
                         object_=_response.json(),
                     ),
                 )