letta-client 0.1.319__py3-none-any.whl → 0.1.321__py3-none-any.whl

letta_client/templates/raw_client.py

@@ -12,6 +12,7 @@ from ..core.serialization import convert_and_respect_annotation_metadata
 from ..core.unchecked_base_model import construct_type
 from ..errors.bad_request_error import BadRequestError
 from ..errors.conflict_error import ConflictError
+from ..errors.internal_server_error import InternalServerError
 from ..errors.not_found_error import NotFoundError
 from ..types.conflict_error_body import ConflictErrorBody
 from .types.templates_create_template_request import TemplatesCreateTemplateRequest
@@ -22,8 +23,10 @@ from .types.templates_get_template_snapshot_response import TemplatesGetTemplate
 from .types.templates_list_request_sort_by import TemplatesListRequestSortBy
 from .types.templates_list_response import TemplatesListResponse
 from .types.templates_list_template_versions_response import TemplatesListTemplateVersionsResponse
+from .types.templates_migrate_deployment_response import TemplatesMigrateDeploymentResponse
 from .types.templates_rename_template_response import TemplatesRenameTemplateResponse
 from .types.templates_save_template_version_response import TemplatesSaveTemplateVersionResponse
+from .types.templates_set_current_template_from_snapshot_response import TemplatesSetCurrentTemplateFromSnapshotResponse
 from .types.templates_update_template_description_response import TemplatesUpdateTemplateDescriptionResponse
 
 # this is used as the default value for optional parameters
@@ -299,6 +302,93 @@ class RawTemplatesClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def setcurrenttemplatefromsnapshot(
+        self,
+        project: str,
+        template_version: str,
+        *,
+        request: typing.Optional[typing.Any] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[TemplatesSetCurrentTemplateFromSnapshotResponse]:
+        """
+        Updates the current working version of a template from a snapshot
+
+        Parameters
+        ----------
+        project : str
+            The project slug
+
+        template_version : str
+            The template name with :current version (e.g., my-template:current)
+
+        request : typing.Optional[typing.Any]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[TemplatesSetCurrentTemplateFromSnapshotResponse]
+            200
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/templates/{jsonable_encoder(project)}/{jsonable_encoder(template_version)}/snapshot",
+            method="PUT",
+            json=request,
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    TemplatesSetCurrentTemplateFromSnapshotResponse,
+                    construct_type(
+                        type_=TemplatesSetCurrentTemplateFromSnapshotResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     def forktemplate(
         self,
         project: str,
@@ -666,6 +756,115 @@ class RawTemplatesClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def migratedeployment(
+        self,
+        project: str,
+        template_name: str,
+        deployment_id: str,
+        *,
+        version: str,
+        preserve_tool_variables: typing.Optional[bool] = OMIT,
+        preserve_core_memories: typing.Optional[bool] = OMIT,
+        memory_variables: typing.Optional[typing.Dict[str, str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[TemplatesMigrateDeploymentResponse]:
+        """
+        Migrates a deployment to a specific template version
+
+        Parameters
+        ----------
+        project : str
+            The project slug
+
+        template_name : str
+            The template name (without version)
+
+        deployment_id : str
+            The deployment ID to migrate
+
+        version : str
+            The target template version to migrate to
+
+        preserve_tool_variables : typing.Optional[bool]
+            Whether to preserve existing tool variables during migration
+
+        preserve_core_memories : typing.Optional[bool]
+            Whether to preserve existing core memories during migration
+
+        memory_variables : typing.Optional[typing.Dict[str, str]]
+            Additional memory variables to apply during migration
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[TemplatesMigrateDeploymentResponse]
+            200
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/templates/{jsonable_encoder(project)}/{jsonable_encoder(template_name)}/deployments/{jsonable_encoder(deployment_id)}/migrate",
+            method="POST",
+            json={
+                "version": version,
+                "preserve_tool_variables": preserve_tool_variables,
+                "preserve_core_memories": preserve_core_memories,
+                "memory_variables": memory_variables,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    TemplatesMigrateDeploymentResponse,
+                    construct_type(
+                        type_=TemplatesMigrateDeploymentResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
 
 class AsyncRawTemplatesClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -936,6 +1135,93 @@ class AsyncRawTemplatesClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    async def setcurrenttemplatefromsnapshot(
+        self,
+        project: str,
+        template_version: str,
+        *,
+        request: typing.Optional[typing.Any] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[TemplatesSetCurrentTemplateFromSnapshotResponse]:
+        """
+        Updates the current working version of a template from a snapshot
+
+        Parameters
+        ----------
+        project : str
+            The project slug
+
+        template_version : str
+            The template name with :current version (e.g., my-template:current)
+
+        request : typing.Optional[typing.Any]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[TemplatesSetCurrentTemplateFromSnapshotResponse]
+            200
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/templates/{jsonable_encoder(project)}/{jsonable_encoder(template_version)}/snapshot",
+            method="PUT",
+            json=request,
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    TemplatesSetCurrentTemplateFromSnapshotResponse,
+                    construct_type(
+                        type_=TemplatesSetCurrentTemplateFromSnapshotResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     async def forktemplate(
         self,
         project: str,
@@ -1302,3 +1588,112 @@ class AsyncRawTemplatesClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def migratedeployment(
+        self,
+        project: str,
+        template_name: str,
+        deployment_id: str,
+        *,
+        version: str,
+        preserve_tool_variables: typing.Optional[bool] = OMIT,
+        preserve_core_memories: typing.Optional[bool] = OMIT,
+        memory_variables: typing.Optional[typing.Dict[str, str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[TemplatesMigrateDeploymentResponse]:
+        """
+        Migrates a deployment to a specific template version
+
+        Parameters
+        ----------
+        project : str
+            The project slug
+
+        template_name : str
+            The template name (without version)
+
+        deployment_id : str
+            The deployment ID to migrate
+
+        version : str
+            The target template version to migrate to
+
+        preserve_tool_variables : typing.Optional[bool]
+            Whether to preserve existing tool variables during migration
+
+        preserve_core_memories : typing.Optional[bool]
+            Whether to preserve existing core memories during migration
+
+        memory_variables : typing.Optional[typing.Dict[str, str]]
+            Additional memory variables to apply during migration
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[TemplatesMigrateDeploymentResponse]
+            200
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/templates/{jsonable_encoder(project)}/{jsonable_encoder(template_name)}/deployments/{jsonable_encoder(deployment_id)}/migrate",
+            method="POST",
+            json={
+                "version": version,
+                "preserve_tool_variables": preserve_tool_variables,
+                "preserve_core_memories": preserve_core_memories,
+                "memory_variables": memory_variables,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    TemplatesMigrateDeploymentResponse,
+                    construct_type(
+                        type_=TemplatesMigrateDeploymentResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        construct_type(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

letta_client/templates/types/__init__.py

@@ -66,14 +66,19 @@ from .templates_get_template_snapshot_response_agents_item_tool_variables_data_i
 )
 from .templates_get_template_snapshot_response_blocks_item import TemplatesGetTemplateSnapshotResponseBlocksItem
 from .templates_get_template_snapshot_response_configuration import TemplatesGetTemplateSnapshotResponseConfiguration
+from .templates_get_template_snapshot_response_relationships_item import (
+    TemplatesGetTemplateSnapshotResponseRelationshipsItem,
+)
 from .templates_get_template_snapshot_response_type import TemplatesGetTemplateSnapshotResponseType
 from .templates_list_request_sort_by import TemplatesListRequestSortBy
 from .templates_list_response import TemplatesListResponse
 from .templates_list_response_templates_item import TemplatesListResponseTemplatesItem
 from .templates_list_template_versions_response import TemplatesListTemplateVersionsResponse
 from .templates_list_template_versions_response_versions_item import TemplatesListTemplateVersionsResponseVersionsItem
+from .templates_migrate_deployment_response import TemplatesMigrateDeploymentResponse
 from .templates_rename_template_response import TemplatesRenameTemplateResponse
 from .templates_save_template_version_response import TemplatesSaveTemplateVersionResponse
+from .templates_set_current_template_from_snapshot_response import TemplatesSetCurrentTemplateFromSnapshotResponse
 from .templates_update_template_description_response import TemplatesUpdateTemplateDescriptionResponse
 
 __all__ = [
@@ -105,13 +110,16 @@ __all__ = [
     "TemplatesGetTemplateSnapshotResponseAgentsItemToolVariablesDataItem",
     "TemplatesGetTemplateSnapshotResponseBlocksItem",
     "TemplatesGetTemplateSnapshotResponseConfiguration",
+    "TemplatesGetTemplateSnapshotResponseRelationshipsItem",
     "TemplatesGetTemplateSnapshotResponseType",
     "TemplatesListRequestSortBy",
     "TemplatesListResponse",
     "TemplatesListResponseTemplatesItem",
     "TemplatesListTemplateVersionsResponse",
     "TemplatesListTemplateVersionsResponseVersionsItem",
+    "TemplatesMigrateDeploymentResponse",
     "TemplatesRenameTemplateResponse",
     "TemplatesSaveTemplateVersionResponse",
+    "TemplatesSetCurrentTemplateFromSnapshotResponse",
     "TemplatesUpdateTemplateDescriptionResponse",
 ]

letta_client/templates/types/templates_get_template_snapshot_response.py

@@ -8,12 +8,16 @@ from ...core.unchecked_base_model import UncheckedBaseModel
 from .templates_get_template_snapshot_response_agents_item import TemplatesGetTemplateSnapshotResponseAgentsItem
 from .templates_get_template_snapshot_response_blocks_item import TemplatesGetTemplateSnapshotResponseBlocksItem
 from .templates_get_template_snapshot_response_configuration import TemplatesGetTemplateSnapshotResponseConfiguration
+from .templates_get_template_snapshot_response_relationships_item import (
+    TemplatesGetTemplateSnapshotResponseRelationshipsItem,
+)
 from .templates_get_template_snapshot_response_type import TemplatesGetTemplateSnapshotResponseType
 
 
 class TemplatesGetTemplateSnapshotResponse(UncheckedBaseModel):
     agents: typing.List[TemplatesGetTemplateSnapshotResponseAgentsItem]
     blocks: typing.List[TemplatesGetTemplateSnapshotResponseBlocksItem]
+    relationships: typing.List[TemplatesGetTemplateSnapshotResponseRelationshipsItem]
     configuration: TemplatesGetTemplateSnapshotResponseConfiguration
     type: TemplatesGetTemplateSnapshotResponseType
     version: str

letta_client/templates/types/templates_get_template_snapshot_response_blocks_item.py

@@ -10,6 +10,7 @@ from ...core.unchecked_base_model import UncheckedBaseModel
 
 
 class TemplatesGetTemplateSnapshotResponseBlocksItem(UncheckedBaseModel):
+    entity_id: typing_extensions.Annotated[str, FieldMetadata(alias="entityId")]
     label: str
     value: str
     limit: float

letta_client/templates/types/templates_get_template_snapshot_response_relationships_item.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+from ...core.serialization import FieldMetadata
+from ...core.unchecked_base_model import UncheckedBaseModel
+
+
+class TemplatesGetTemplateSnapshotResponseRelationshipsItem(UncheckedBaseModel):
+    agent_entity_id: typing_extensions.Annotated[str, FieldMetadata(alias="agentEntityId")]
+    block_entity_id: typing_extensions.Annotated[str, FieldMetadata(alias="blockEntityId")]
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/templates/types/templates_migrate_deployment_response.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+from ...core.unchecked_base_model import UncheckedBaseModel
+
+
+class TemplatesMigrateDeploymentResponse(UncheckedBaseModel):
+    success: bool
+    message: typing.Optional[str] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/templates/types/templates_set_current_template_from_snapshot_response.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2
+from ...core.unchecked_base_model import UncheckedBaseModel
+
+
+class TemplatesSetCurrentTemplateFromSnapshotResponse(UncheckedBaseModel):
+    success: bool
+    message: typing.Optional[str] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

letta_client/tools/__init__.py

@@ -11,6 +11,7 @@ from .types import (
     ListMcpServersResponseValue,
     StreamingResponse,
     TestMcpServerRequest,
+    ToolsListRequestOrder,
     UpdateMcpServerRequest,
     UpdateMcpServerResponse,
 )
@@ -24,6 +25,7 @@ __all__ = [
     "ListMcpServersResponseValue",
     "StreamingResponse",
     "TestMcpServerRequest",
+    "ToolsListRequestOrder",
     "UpdateMcpServerRequest",
     "UpdateMcpServerResponse",
 ]