letta-client 0.1.324__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

letta_client/chat/client.py

@@ -0,0 +1,255 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..types.chat_completion import ChatCompletion
+from .raw_client import AsyncRawChatClient, RawChatClient
+from .types.chat_completion_request_messages_item import ChatCompletionRequestMessagesItem
+from .types.chat_completion_request_stop import ChatCompletionRequestStop
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class ChatClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawChatClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawChatClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawChatClient
+        """
+        return self._raw_client
+
+    def create_chat_completion(
+        self,
+        *,
+        model: str,
+        messages: typing.Sequence[ChatCompletionRequestMessagesItem],
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[ChatCompletionRequestStop] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        user: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ChatCompletion:
+        """
+        Create a chat completion using a Letta agent (OpenAI-compatible).
+
+        This endpoint provides full OpenAI API compatibility. The agent is selected based on:
+        - The 'model' parameter in the request (should contain an agent ID in format 'agent-...')
+
+        When streaming is enabled (stream=true), the response will be Server-Sent Events
+        with ChatCompletionChunk objects.
+
+        Parameters
+        ----------
+        model : str
+            ID of the model to use
+
+        messages : typing.Sequence[ChatCompletionRequestMessagesItem]
+            Messages comprising the conversation so far
+
+        temperature : typing.Optional[float]
+            Sampling temperature
+
+        top_p : typing.Optional[float]
+            Nucleus sampling parameter
+
+        n : typing.Optional[int]
+            Number of chat completion choices to generate
+
+        stream : typing.Optional[bool]
+            Whether to stream back partial progress
+
+        stop : typing.Optional[ChatCompletionRequestStop]
+            Sequences where the API will stop generating
+
+        max_tokens : typing.Optional[int]
+            Maximum number of tokens to generate
+
+        presence_penalty : typing.Optional[float]
+            Presence penalty
+
+        frequency_penalty : typing.Optional[float]
+            Frequency penalty
+
+        user : typing.Optional[str]
+            A unique identifier representing your end-user
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ChatCompletion
+            Successful response
+
+        Examples
+        --------
+        from letta_client import ChatCompletionDeveloperMessageParam, Letta
+
+        client = Letta(
+            project="YOUR_PROJECT",
+            token="YOUR_TOKEN",
+        )
+        client.chat.create_chat_completion(
+            model="model",
+            messages=[
+                ChatCompletionDeveloperMessageParam(
+                    content="content",
+                )
+            ],
+        )
+        """
+        _response = self._raw_client.create_chat_completion(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            top_p=top_p,
+            n=n,
+            stream=stream,
+            stop=stop,
+            max_tokens=max_tokens,
+            presence_penalty=presence_penalty,
+            frequency_penalty=frequency_penalty,
+            user=user,
+            request_options=request_options,
+        )
+        return _response.data
+
+
+class AsyncChatClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawChatClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawChatClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawChatClient
+        """
+        return self._raw_client
+
+    async def create_chat_completion(
+        self,
+        *,
+        model: str,
+        messages: typing.Sequence[ChatCompletionRequestMessagesItem],
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[ChatCompletionRequestStop] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        user: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> ChatCompletion:
+        """
+        Create a chat completion using a Letta agent (OpenAI-compatible).
+
+        This endpoint provides full OpenAI API compatibility. The agent is selected based on:
+        - The 'model' parameter in the request (should contain an agent ID in format 'agent-...')
+
+        When streaming is enabled (stream=true), the response will be Server-Sent Events
+        with ChatCompletionChunk objects.
+
+        Parameters
+        ----------
+        model : str
+            ID of the model to use
+
+        messages : typing.Sequence[ChatCompletionRequestMessagesItem]
+            Messages comprising the conversation so far
+
+        temperature : typing.Optional[float]
+            Sampling temperature
+
+        top_p : typing.Optional[float]
+            Nucleus sampling parameter
+
+        n : typing.Optional[int]
+            Number of chat completion choices to generate
+
+        stream : typing.Optional[bool]
+            Whether to stream back partial progress
+
+        stop : typing.Optional[ChatCompletionRequestStop]
+            Sequences where the API will stop generating
+
+        max_tokens : typing.Optional[int]
+            Maximum number of tokens to generate
+
+        presence_penalty : typing.Optional[float]
+            Presence penalty
+
+        frequency_penalty : typing.Optional[float]
+            Frequency penalty
+
+        user : typing.Optional[str]
+            A unique identifier representing your end-user
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        ChatCompletion
+            Successful response
+
+        Examples
+        --------
+        import asyncio
+
+        from letta_client import AsyncLetta, ChatCompletionDeveloperMessageParam
+
+        client = AsyncLetta(
+            project="YOUR_PROJECT",
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.chat.create_chat_completion(
+                model="model",
+                messages=[
+                    ChatCompletionDeveloperMessageParam(
+                        content="content",
+                    )
+                ],
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.create_chat_completion(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            top_p=top_p,
+            n=n,
+            stream=stream,
+            stop=stop,
+            max_tokens=max_tokens,
+            presence_penalty=presence_penalty,
+            frequency_penalty=frequency_penalty,
+            user=user,
+            request_options=request_options,
+        )
+        return _response.data

letta_client/chat/raw_client.py

@@ -0,0 +1,269 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.request_options import RequestOptions
+from ..core.serialization import convert_and_respect_annotation_metadata
+from ..core.unchecked_base_model import construct_type
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.chat_completion import ChatCompletion
+from ..types.http_validation_error import HttpValidationError
+from .types.chat_completion_request_messages_item import ChatCompletionRequestMessagesItem
+from .types.chat_completion_request_stop import ChatCompletionRequestStop
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawChatClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def create_chat_completion(
+        self,
+        *,
+        model: str,
+        messages: typing.Sequence[ChatCompletionRequestMessagesItem],
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[ChatCompletionRequestStop] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        user: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[ChatCompletion]:
+        """
+        Create a chat completion using a Letta agent (OpenAI-compatible).
+
+        This endpoint provides full OpenAI API compatibility. The agent is selected based on:
+        - The 'model' parameter in the request (should contain an agent ID in format 'agent-...')
+
+        When streaming is enabled (stream=true), the response will be Server-Sent Events
+        with ChatCompletionChunk objects.
+
+        Parameters
+        ----------
+        model : str
+            ID of the model to use
+
+        messages : typing.Sequence[ChatCompletionRequestMessagesItem]
+            Messages comprising the conversation so far
+
+        temperature : typing.Optional[float]
+            Sampling temperature
+
+        top_p : typing.Optional[float]
+            Nucleus sampling parameter
+
+        n : typing.Optional[int]
+            Number of chat completion choices to generate
+
+        stream : typing.Optional[bool]
+            Whether to stream back partial progress
+
+        stop : typing.Optional[ChatCompletionRequestStop]
+            Sequences where the API will stop generating
+
+        max_tokens : typing.Optional[int]
+            Maximum number of tokens to generate
+
+        presence_penalty : typing.Optional[float]
+            Presence penalty
+
+        frequency_penalty : typing.Optional[float]
+            Frequency penalty
+
+        user : typing.Optional[str]
+            A unique identifier representing your end-user
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[ChatCompletion]
+            Successful response
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/chat/completions",
+            method="POST",
+            json={
+                "model": model,
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessagesItem], direction="write"
+                ),
+                "temperature": temperature,
+                "top_p": top_p,
+                "n": n,
+                "stream": stream,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=ChatCompletionRequestStop, direction="write"
+                ),
+                "max_tokens": max_tokens,
+                "presence_penalty": presence_penalty,
+                "frequency_penalty": frequency_penalty,
+                "user": user,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    ChatCompletion,
+                    construct_type(
+                        type_=ChatCompletion,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=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, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawChatClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def create_chat_completion(
+        self,
+        *,
+        model: str,
+        messages: typing.Sequence[ChatCompletionRequestMessagesItem],
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[ChatCompletionRequestStop] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        user: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[ChatCompletion]:
+        """
+        Create a chat completion using a Letta agent (OpenAI-compatible).
+
+        This endpoint provides full OpenAI API compatibility. The agent is selected based on:
+        - The 'model' parameter in the request (should contain an agent ID in format 'agent-...')
+
+        When streaming is enabled (stream=true), the response will be Server-Sent Events
+        with ChatCompletionChunk objects.
+
+        Parameters
+        ----------
+        model : str
+            ID of the model to use
+
+        messages : typing.Sequence[ChatCompletionRequestMessagesItem]
+            Messages comprising the conversation so far
+
+        temperature : typing.Optional[float]
+            Sampling temperature
+
+        top_p : typing.Optional[float]
+            Nucleus sampling parameter
+
+        n : typing.Optional[int]
+            Number of chat completion choices to generate
+
+        stream : typing.Optional[bool]
+            Whether to stream back partial progress
+
+        stop : typing.Optional[ChatCompletionRequestStop]
+            Sequences where the API will stop generating
+
+        max_tokens : typing.Optional[int]
+            Maximum number of tokens to generate
+
+        presence_penalty : typing.Optional[float]
+            Presence penalty
+
+        frequency_penalty : typing.Optional[float]
+            Frequency penalty
+
+        user : typing.Optional[str]
+            A unique identifier representing your end-user
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[ChatCompletion]
+            Successful response
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/chat/completions",
+            method="POST",
+            json={
+                "model": model,
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessagesItem], direction="write"
+                ),
+                "temperature": temperature,
+                "top_p": top_p,
+                "n": n,
+                "stream": stream,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=ChatCompletionRequestStop, direction="write"
+                ),
+                "max_tokens": max_tokens,
+                "presence_penalty": presence_penalty,
+                "frequency_penalty": frequency_penalty,
+                "user": user,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    ChatCompletion,
+                    construct_type(
+                        type_=ChatCompletion,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=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, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

letta_client/chat/types/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .chat_completion_request_messages_item import ChatCompletionRequestMessagesItem
+from .chat_completion_request_stop import ChatCompletionRequestStop
+
+__all__ = ["ChatCompletionRequestMessagesItem", "ChatCompletionRequestStop"]

letta_client/chat/types/chat_completion_request_messages_item.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ...types.chat_completion_assistant_message_param import ChatCompletionAssistantMessageParam
+from ...types.chat_completion_developer_message_param import ChatCompletionDeveloperMessageParam
+from ...types.chat_completion_function_message_param import ChatCompletionFunctionMessageParam
+from ...types.chat_completion_system_message_param import ChatCompletionSystemMessageParam
+from ...types.chat_completion_tool_message_param import ChatCompletionToolMessageParam
+from ...types.chat_completion_user_message_param import ChatCompletionUserMessageParam
+
+ChatCompletionRequestMessagesItem = typing.Union[
+    ChatCompletionDeveloperMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionUserMessageParam,
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionToolMessageParam,
+    ChatCompletionFunctionMessageParam,
+]

letta_client/chat/types/chat_completion_request_stop.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ChatCompletionRequestStop = typing.Union[str, typing.List[str]]

letta_client/client_side_access_tokens/client.py

@@ -68,7 +68,11 @@ class ClientSideAccessTokensClient:
             project="YOUR_PROJECT",
             token="YOUR_TOKEN",
         )
-        client.client_side_access_tokens.client_side_access_tokens_list_client_side_access_tokens()
+        client.client_side_access_tokens.client_side_access_tokens_list_client_side_access_tokens(
+            agent_id="agentId",
+            offset=1.1,
+            limit=1.1,
+        )
         """
         _response = self._raw_client.client_side_access_tokens_list_client_side_access_tokens(
             agent_id=agent_id, offset=offset, limit=limit, request_options=request_options
@@ -230,7 +234,11 @@ class AsyncClientSideAccessTokensClient:
 
 
         async def main() -> None:
-            await client.client_side_access_tokens.client_side_access_tokens_list_client_side_access_tokens()
+            await client.client_side_access_tokens.client_side_access_tokens_list_client_side_access_tokens(
+                agent_id="agentId",
+                offset=1.1,
+                limit=1.1,
+            )
 
 
         asyncio.run(main())

letta_client/core/client_wrapper.py

@@ -24,10 +24,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "letta-client/0.1.324",
+            "User-Agent": "letta-client/1.0.0a2",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "letta-client",
-            "X-Fern-SDK-Version": "0.1.324",
+            "X-Fern-SDK-Version": "1.0.0a2",
             **(self.get_custom_headers() or {}),
         }
         if self._project is not None:

letta_client/errors/__init__.py

@@ -4,6 +4,7 @@
 
 from .bad_request_error import BadRequestError
 from .conflict_error import ConflictError
+from .gone_error import GoneError
 from .internal_server_error import InternalServerError
 from .not_found_error import NotFoundError
 from .payment_required_error import PaymentRequiredError
@@ -12,6 +13,7 @@ from .unprocessable_entity_error import UnprocessableEntityError
 __all__ = [
     "BadRequestError",
     "ConflictError",
+    "GoneError",
     "InternalServerError",
     "NotFoundError",
     "PaymentRequiredError",

letta_client/errors/gone_error.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.api_error import ApiError
+
+
+class GoneError(ApiError):
+    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
+        super().__init__(status_code=410, headers=headers, body=body)

letta_client/folders/agents/client.py

@@ -74,6 +74,10 @@ class AgentsClient:
         )
         client.folders.agents.list(
             folder_id="folder_id",
+            before="before",
+            after="after",
+            limit=1,
+            order="asc",
         )
         """
         _response = self._raw_client.list(
@@ -159,6 +163,10 @@ class AsyncAgentsClient:
         async def main() -> None:
             await client.folders.agents.list(
                 folder_id="folder_id",
+                before="before",
+                after="after",
+                limit=1,
+                order="asc",
             )