c63a5cfe-b235-4fbe-8bbb-82a9e02a482a-python 0.1.0a5__py3-none-any.whl → 0.1.0a7__py3-none-any.whl

{do_gradientai → gradientai}/resources/models.py

@@ -2,9 +2,14 @@
 
 from __future__ import annotations
 
+from typing import List
+from typing_extensions import Literal
+
 import httpx
 
+from ..types import model_list_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -13,7 +18,6 @@ from .._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from ..types.model import Model
 from .._base_client import make_request_options
 from ..types.model_list_response import ModelListResponse
 
@@ -40,22 +44,52 @@ class ModelsResource(SyncAPIResource):
         """
         return ModelsResourceWithStreamingResponse(self)
 
-    def retrieve(
+    def list(
         self,
-        model: str,
         *,
+        page: int | NotGiven = NOT_GIVEN,
+        per_page: int | NotGiven = NOT_GIVEN,
+        public_only: bool | NotGiven = NOT_GIVEN,
+        usecases: List[
+            Literal[
+                "MODEL_USECASE_UNKNOWN",
+                "MODEL_USECASE_AGENT",
+                "MODEL_USECASE_FINETUNED",
+                "MODEL_USECASE_KNOWLEDGEBASE",
+                "MODEL_USECASE_GUARDRAIL",
+                "MODEL_USECASE_REASONING",
+                "MODEL_USECASE_SERVERLESS",
+            ]
+        ]
+        | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Model:
+    ) -> ModelListResponse:
         """
-        Retrieves a model instance, providing basic information about the model such as
-        the owner and permissioning.
+        To list all models, send a GET request to `/v2/gen-ai/models`.
 
         Args:
+          page: page number.
+
+          per_page: items per page.
+
+          public_only: only include models that are publicly available.
+
+          usecases: include only models defined for the listed usecases.
+
+              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
+              - MODEL_USECASE_AGENT: The model maybe used in an agent
+              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
+              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
+                (embedding models)
+              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
+              - MODEL_USECASE_REASONING: The model usecase for reasoning
+              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -64,36 +98,24 @@ class ModelsResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not model:
-            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
         return self._get(
-            f"/models/{model}"
+            "/v2/gen-ai/models"
             if self._client._base_url_overridden
-            else f"https://inference.do-ai.run/v1/models/{model}",
+            else "https://api.digitalocean.com/v2/gen-ai/models",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Model,
-        )
-
-    def list(
-        self,
-        *,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ModelListResponse:
-        """
-        Lists the currently available models, and provides basic information about each
-        one such as the owner and availability.
-        """
-        return self._get(
-            "/models" if self._client._base_url_overridden else "https://inference.do-ai.run/v1/models",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "page": page,
+                        "per_page": per_page,
+                        "public_only": public_only,
+                        "usecases": usecases,
+                    },
+                    model_list_params.ModelListParams,
+                ),
             ),
             cast_to=ModelListResponse,
         )
@@ -119,22 +141,52 @@ class AsyncModelsResource(AsyncAPIResource):
         """
         return AsyncModelsResourceWithStreamingResponse(self)
 
-    async def retrieve(
+    async def list(
         self,
-        model: str,
         *,
+        page: int | NotGiven = NOT_GIVEN,
+        per_page: int | NotGiven = NOT_GIVEN,
+        public_only: bool | NotGiven = NOT_GIVEN,
+        usecases: List[
+            Literal[
+                "MODEL_USECASE_UNKNOWN",
+                "MODEL_USECASE_AGENT",
+                "MODEL_USECASE_FINETUNED",
+                "MODEL_USECASE_KNOWLEDGEBASE",
+                "MODEL_USECASE_GUARDRAIL",
+                "MODEL_USECASE_REASONING",
+                "MODEL_USECASE_SERVERLESS",
+            ]
+        ]
+        | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Model:
+    ) -> ModelListResponse:
         """
-        Retrieves a model instance, providing basic information about the model such as
-        the owner and permissioning.
+        To list all models, send a GET request to `/v2/gen-ai/models`.
 
         Args:
+          page: page number.
+
+          per_page: items per page.
+
+          public_only: only include models that are publicly available.
+
+          usecases: include only models defined for the listed usecases.
+
+              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
+              - MODEL_USECASE_AGENT: The model maybe used in an agent
+              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
+              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
+                (embedding models)
+              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
+              - MODEL_USECASE_REASONING: The model usecase for reasoning
+              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -143,36 +195,24 @@ class AsyncModelsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not model:
-            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
         return await self._get(
-            f"/models/{model}"
+            "/v2/gen-ai/models"
             if self._client._base_url_overridden
-            else f"https://inference.do-ai.run/v1/models/{model}",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Model,
-        )
-
-    async def list(
-        self,
-        *,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ModelListResponse:
-        """
-        Lists the currently available models, and provides basic information about each
-        one such as the owner and availability.
-        """
-        return await self._get(
-            "/models" if self._client._base_url_overridden else "https://inference.do-ai.run/v1/models",
+            else "https://api.digitalocean.com/v2/gen-ai/models",
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "page": page,
+                        "per_page": per_page,
+                        "public_only": public_only,
+                        "usecases": usecases,
+                    },
+                    model_list_params.ModelListParams,
+                ),
             ),
             cast_to=ModelListResponse,
         )
@@ -182,9 +222,6 @@ class ModelsResourceWithRawResponse:
     def __init__(self, models: ModelsResource) -> None:
         self._models = models
 
-        self.retrieve = to_raw_response_wrapper(
-            models.retrieve,
-        )
         self.list = to_raw_response_wrapper(
             models.list,
         )
@@ -194,9 +231,6 @@ class AsyncModelsResourceWithRawResponse:
     def __init__(self, models: AsyncModelsResource) -> None:
         self._models = models
 
-        self.retrieve = async_to_raw_response_wrapper(
-            models.retrieve,
-        )
         self.list = async_to_raw_response_wrapper(
             models.list,
         )
@@ -206,9 +240,6 @@ class ModelsResourceWithStreamingResponse:
     def __init__(self, models: ModelsResource) -> None:
         self._models = models
 
-        self.retrieve = to_streamed_response_wrapper(
-            models.retrieve,
-        )
         self.list = to_streamed_response_wrapper(
             models.list,
         )
@@ -218,9 +249,6 @@ class AsyncModelsResourceWithStreamingResponse:
     def __init__(self, models: AsyncModelsResource) -> None:
         self._models = models
 
-        self.retrieve = async_to_streamed_response_wrapper(
-            models.retrieve,
-        )
         self.list = async_to_streamed_response_wrapper(
             models.list,
         )

{do_gradientai → gradientai}/types/__init__.py

@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
-from .model import Model as Model
-from .shared import APIMeta as APIMeta, APILinks as APILinks
+from .shared import APIMeta as APIMeta, APILinks as APILinks, ChatCompletionTokenLogprob as ChatCompletionTokenLogprob
 from .api_agent import APIAgent as APIAgent
+from .api_model import APIModel as APIModel
 from .api_agreement import APIAgreement as APIAgreement
 from .api_workspace import APIWorkspace as APIWorkspace
 from .api_agent_model import APIAgentModel as APIAgentModel
 from .agent_list_params import AgentListParams as AgentListParams
 from .api_model_version import APIModelVersion as APIModelVersion
+from .model_list_params import ModelListParams as ModelListParams
 from .api_knowledge_base import APIKnowledgeBase as APIKnowledgeBase
 from .region_list_params import RegionListParams as RegionListParams
 from .agent_create_params import AgentCreateParams as AgentCreateParams

{do_gradientai/types → gradientai/types/agents}/chat/__init__.py

@@ -4,4 +4,3 @@ from __future__ import annotations
 
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
 from .completion_create_response import CompletionCreateResponse as CompletionCreateResponse
-from .chat_completion_token_logprob import ChatCompletionTokenLogprob as ChatCompletionTokenLogprob

gradientai/types/agents/chat/completion_create_response.py

@@ -0,0 +1,81 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from ...shared.chat_completion_token_logprob import ChatCompletionTokenLogprob
+
+__all__ = ["CompletionCreateResponse", "Choice", "ChoiceLogprobs", "ChoiceMessage", "Usage"]
+
+
+class ChoiceLogprobs(BaseModel):
+    content: Optional[List[ChatCompletionTokenLogprob]] = None
+    """A list of message content tokens with log probability information."""
+
+    refusal: Optional[List[ChatCompletionTokenLogprob]] = None
+    """A list of message refusal tokens with log probability information."""
+
+
+class ChoiceMessage(BaseModel):
+    content: Optional[str] = None
+    """The contents of the message."""
+
+    refusal: Optional[str] = None
+    """The refusal message generated by the model."""
+
+    role: Literal["assistant"]
+    """The role of the author of this message."""
+
+
+class Choice(BaseModel):
+    finish_reason: Literal["stop", "length"]
+    """The reason the model stopped generating tokens.
+
+    This will be `stop` if the model hit a natural stop point or a provided stop
+    sequence, or `length` if the maximum number of tokens specified in the request
+    was reached.
+    """
+
+    index: int
+    """The index of the choice in the list of choices."""
+
+    logprobs: Optional[ChoiceLogprobs] = None
+    """Log probability information for the choice."""
+
+    message: ChoiceMessage
+    """A chat completion message generated by the model."""
+
+
+class Usage(BaseModel):
+    completion_tokens: int
+    """Number of tokens in the generated completion."""
+
+    prompt_tokens: int
+    """Number of tokens in the prompt."""
+
+    total_tokens: int
+    """Total number of tokens used in the request (prompt + completion)."""
+
+
+class CompletionCreateResponse(BaseModel):
+    id: str
+    """A unique identifier for the chat completion."""
+
+    choices: List[Choice]
+    """A list of chat completion choices.
+
+    Can be more than one if `n` is greater than 1.
+    """
+
+    created: int
+    """The Unix timestamp (in seconds) of when the chat completion was created."""
+
+    model: str
+    """The model used for the chat completion."""
+
+    object: Literal["chat.completion"]
+    """The object type, which is always `chat.completion`."""
+
+    usage: Optional[Usage] = None
+    """Usage statistics for the completion request."""

gradientai/types/api_model.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from .._models import BaseModel
+from .api_agreement import APIAgreement
+from .api_model_version import APIModelVersion
+
+__all__ = ["APIModel"]
+
+
+class APIModel(BaseModel):
+    agreement: Optional[APIAgreement] = None
+
+    created_at: Optional[datetime] = None
+
+    is_foundational: Optional[bool] = None
+
+    name: Optional[str] = None
+
+    parent_uuid: Optional[str] = None
+
+    updated_at: Optional[datetime] = None
+
+    upload_complete: Optional[bool] = None
+
+    url: Optional[str] = None
+
+    uuid: Optional[str] = None
+
+    version: Optional[APIModelVersion] = None

gradientai/types/chat/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .completion_create_params import CompletionCreateParams as CompletionCreateParams
+from .completion_create_response import CompletionCreateResponse as CompletionCreateResponse

gradientai/types/chat/completion_create_params.py

@@ -0,0 +1,185 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = [
+    "CompletionCreateParams",
+    "Message",
+    "MessageChatCompletionRequestSystemMessage",
+    "MessageChatCompletionRequestDeveloperMessage",
+    "MessageChatCompletionRequestUserMessage",
+    "MessageChatCompletionRequestAssistantMessage",
+    "StreamOptions",
+]
+
+
+class CompletionCreateParams(TypedDict, total=False):
+    messages: Required[Iterable[Message]]
+    """A list of messages comprising the conversation so far."""
+
+    model: Required[str]
+    """Model ID used to generate the response."""
+
+    frequency_penalty: Optional[float]
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on their existing frequency in the
+    text so far, decreasing the model's likelihood to repeat the same line verbatim.
+    """
+
+    logit_bias: Optional[Dict[str, int]]
+    """Modify the likelihood of specified tokens appearing in the completion.
+
+    Accepts a JSON object that maps tokens (specified by their token ID in the
+    tokenizer) to an associated bias value from -100 to 100. Mathematically, the
+    bias is added to the logits generated by the model prior to sampling. The exact
+    effect will vary per model, but values between -1 and 1 should decrease or
+    increase likelihood of selection; values like -100 or 100 should result in a ban
+    or exclusive selection of the relevant token.
+    """
+
+    logprobs: Optional[bool]
+    """Whether to return log probabilities of the output tokens or not.
+
+    If true, returns the log probabilities of each output token returned in the
+    `content` of `message`.
+    """
+
+    max_completion_tokens: Optional[int]
+    """
+    The maximum number of completion tokens that may be used over the course of the
+    run. The run will make a best effort to use only the number of completion tokens
+    specified, across multiple turns of the run.
+    """
+
+    max_tokens: Optional[int]
+    """The maximum number of tokens that can be generated in the completion.
+
+    The token count of your prompt plus `max_tokens` cannot exceed the model's
+    context length.
+    """
+
+    metadata: Optional[Dict[str, str]]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    n: Optional[int]
+    """How many chat completion choices to generate for each input message.
+
+    Note that you will be charged based on the number of generated tokens across all
+    of the choices. Keep `n` as `1` to minimize costs.
+    """
+
+    presence_penalty: Optional[float]
+    """Number between -2.0 and 2.0.
+
+    Positive values penalize new tokens based on whether they appear in the text so
+    far, increasing the model's likelihood to talk about new topics.
+    """
+
+    stop: Union[Optional[str], List[str], None]
+    """Up to 4 sequences where the API will stop generating further tokens.
+
+    The returned text will not contain the stop sequence.
+    """
+
+    stream: Optional[bool]
+    """
+    If set to true, the model response data will be streamed to the client as it is
+    generated using server-sent events.
+    """
+
+    stream_options: Optional[StreamOptions]
+    """Options for streaming response. Only set this when you set `stream: true`."""
+
+    temperature: Optional[float]
+    """What sampling temperature to use, between 0 and 2.
+
+    Higher values like 0.8 will make the output more random, while lower values like
+    0.2 will make it more focused and deterministic. We generally recommend altering
+    this or `top_p` but not both.
+    """
+
+    top_logprobs: Optional[int]
+    """
+    An integer between 0 and 20 specifying the number of most likely tokens to
+    return at each token position, each with an associated log probability.
+    `logprobs` must be set to `true` if this parameter is used.
+    """
+
+    top_p: Optional[float]
+    """
+    An alternative to sampling with temperature, called nucleus sampling, where the
+    model considers the results of the tokens with top_p probability mass. So 0.1
+    means only the tokens comprising the top 10% probability mass are considered.
+
+    We generally recommend altering this or `temperature` but not both.
+    """
+
+    user: str
+    """
+    A unique identifier representing your end-user, which can help DigitalOcean to
+    monitor and detect abuse.
+    """
+
+
+class MessageChatCompletionRequestSystemMessage(TypedDict, total=False):
+    content: Required[Union[str, List[str]]]
+    """The contents of the system message."""
+
+    role: Required[Literal["system"]]
+    """The role of the messages author, in this case `system`."""
+
+
+class MessageChatCompletionRequestDeveloperMessage(TypedDict, total=False):
+    content: Required[Union[str, List[str]]]
+    """The contents of the developer message."""
+
+    role: Required[Literal["developer"]]
+    """The role of the messages author, in this case `developer`."""
+
+
+class MessageChatCompletionRequestUserMessage(TypedDict, total=False):
+    content: Required[Union[str, List[str]]]
+    """The contents of the user message."""
+
+    role: Required[Literal["user"]]
+    """The role of the messages author, in this case `user`."""
+
+
+class MessageChatCompletionRequestAssistantMessage(TypedDict, total=False):
+    role: Required[Literal["assistant"]]
+    """The role of the messages author, in this case `assistant`."""
+
+    content: Union[str, List[str], None]
+    """The contents of the assistant message."""
+
+
+Message: TypeAlias = Union[
+    MessageChatCompletionRequestSystemMessage,
+    MessageChatCompletionRequestDeveloperMessage,
+    MessageChatCompletionRequestUserMessage,
+    MessageChatCompletionRequestAssistantMessage,
+]
+
+
+class StreamOptions(TypedDict, total=False):
+    include_usage: bool
+    """If set, an additional chunk will be streamed before the `data: [DONE]` message.
+
+    The `usage` field on this chunk shows the token usage statistics for the entire
+    request, and the `choices` field will always be an empty array.
+
+    All other chunks will also include a `usage` field, but with a null value.
+    **NOTE:** If the stream is interrupted, you may not receive the final usage
+    chunk which contains the total token usage for the request.
+    """

{do_gradientai → gradientai}/types/chat/completion_create_response.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 from typing_extensions import Literal
 
 from ..._models import BaseModel
-from .chat_completion_token_logprob import ChatCompletionTokenLogprob
+from ..shared.chat_completion_token_logprob import ChatCompletionTokenLogprob
 
 __all__ = ["CompletionCreateResponse", "Choice", "ChoiceLogprobs", "ChoiceMessage", "Usage"]
 

gradientai/types/model_list_params.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ModelListParams"]
+
+
+class ModelListParams(TypedDict, total=False):
+    page: int
+    """page number."""
+
+    per_page: int
+    """items per page."""
+
+    public_only: bool
+    """only include models that are publicly available."""
+
+    usecases: List[
+        Literal[
+            "MODEL_USECASE_UNKNOWN",
+            "MODEL_USECASE_AGENT",
+            "MODEL_USECASE_FINETUNED",
+            "MODEL_USECASE_KNOWLEDGEBASE",
+            "MODEL_USECASE_GUARDRAIL",
+            "MODEL_USECASE_REASONING",
+            "MODEL_USECASE_SERVERLESS",
+        ]
+    ]
+    """include only models defined for the listed usecases.
+
+    - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
+    - MODEL_USECASE_AGENT: The model maybe used in an agent
+    - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
+    - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
+      (embedding models)
+    - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
+    - MODEL_USECASE_REASONING: The model usecase for reasoning
+    - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
+    """

gradientai/types/model_list_response.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+from .api_model import APIModel
+from .shared.api_meta import APIMeta
+from .shared.api_links import APILinks
+
+__all__ = ["ModelListResponse"]
+
+
+class ModelListResponse(BaseModel):
+    links: Optional[APILinks] = None
+
+    meta: Optional[APIMeta] = None
+
+    models: Optional[List[APIModel]] = None