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

{digitalocean_genai_sdk → gradientai}/resources/agents/functions.py

@@ -30,7 +30,7 @@ class FunctionsResource(SyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return FunctionsResourceWithRawResponse(self)
 
@@ -39,7 +39,7 @@ class FunctionsResource(SyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return FunctionsResourceWithStreamingResponse(self)
 
@@ -77,7 +77,9 @@ class FunctionsResource(SyncAPIResource):
         if not path_agent_uuid:
             raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
         return self._post(
-            f"/v2/genai/agents/{path_agent_uuid}/functions",
+            f"/v2/gen-ai/agents/{path_agent_uuid}/functions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_agent_uuid}/functions",
             body=maybe_transform(
                 {
                     "body_agent_uuid": body_agent_uuid,
@@ -134,7 +136,9 @@ class FunctionsResource(SyncAPIResource):
         if not path_function_uuid:
             raise ValueError(f"Expected a non-empty value for `path_function_uuid` but received {path_function_uuid!r}")
         return self._put(
-            f"/v2/genai/agents/{path_agent_uuid}/functions/{path_function_uuid}",
+            f"/v2/gen-ai/agents/{path_agent_uuid}/functions/{path_function_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_agent_uuid}/functions/{path_function_uuid}",
             body=maybe_transform(
                 {
                     "body_agent_uuid": body_agent_uuid,
@@ -184,7 +188,9 @@ class FunctionsResource(SyncAPIResource):
         if not function_uuid:
             raise ValueError(f"Expected a non-empty value for `function_uuid` but received {function_uuid!r}")
         return self._delete(
-            f"/v2/genai/agents/{agent_uuid}/functions/{function_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/functions/{function_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/functions/{function_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -199,7 +205,7 @@ class AsyncFunctionsResource(AsyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return AsyncFunctionsResourceWithRawResponse(self)
 
@@ -208,7 +214,7 @@ class AsyncFunctionsResource(AsyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return AsyncFunctionsResourceWithStreamingResponse(self)
 
@@ -246,7 +252,9 @@ class AsyncFunctionsResource(AsyncAPIResource):
         if not path_agent_uuid:
             raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
         return await self._post(
-            f"/v2/genai/agents/{path_agent_uuid}/functions",
+            f"/v2/gen-ai/agents/{path_agent_uuid}/functions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_agent_uuid}/functions",
             body=await async_maybe_transform(
                 {
                     "body_agent_uuid": body_agent_uuid,
@@ -303,7 +311,9 @@ class AsyncFunctionsResource(AsyncAPIResource):
         if not path_function_uuid:
             raise ValueError(f"Expected a non-empty value for `path_function_uuid` but received {path_function_uuid!r}")
         return await self._put(
-            f"/v2/genai/agents/{path_agent_uuid}/functions/{path_function_uuid}",
+            f"/v2/gen-ai/agents/{path_agent_uuid}/functions/{path_function_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_agent_uuid}/functions/{path_function_uuid}",
             body=await async_maybe_transform(
                 {
                     "body_agent_uuid": body_agent_uuid,
@@ -353,7 +363,9 @@ class AsyncFunctionsResource(AsyncAPIResource):
         if not function_uuid:
             raise ValueError(f"Expected a non-empty value for `function_uuid` but received {function_uuid!r}")
         return await self._delete(
-            f"/v2/genai/agents/{agent_uuid}/functions/{function_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/functions/{function_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/functions/{function_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

{digitalocean_genai_sdk → gradientai}/resources/agents/knowledge_bases.py

@@ -27,7 +27,7 @@ class KnowledgeBasesResource(SyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return KnowledgeBasesResourceWithRawResponse(self)
 
@@ -36,7 +36,7 @@ class KnowledgeBasesResource(SyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return KnowledgeBasesResourceWithStreamingResponse(self)
 
@@ -67,7 +67,9 @@ class KnowledgeBasesResource(SyncAPIResource):
         if not agent_uuid:
             raise ValueError(f"Expected a non-empty value for `agent_uuid` but received {agent_uuid!r}")
         return self._post(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -106,7 +108,9 @@ class KnowledgeBasesResource(SyncAPIResource):
                 f"Expected a non-empty value for `knowledge_base_uuid` but received {knowledge_base_uuid!r}"
             )
         return self._post(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -145,7 +149,9 @@ class KnowledgeBasesResource(SyncAPIResource):
                 f"Expected a non-empty value for `knowledge_base_uuid` but received {knowledge_base_uuid!r}"
             )
         return self._delete(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -160,7 +166,7 @@ class AsyncKnowledgeBasesResource(AsyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return AsyncKnowledgeBasesResourceWithRawResponse(self)
 
@@ -169,7 +175,7 @@ class AsyncKnowledgeBasesResource(AsyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return AsyncKnowledgeBasesResourceWithStreamingResponse(self)
 
@@ -200,7 +206,9 @@ class AsyncKnowledgeBasesResource(AsyncAPIResource):
         if not agent_uuid:
             raise ValueError(f"Expected a non-empty value for `agent_uuid` but received {agent_uuid!r}")
         return await self._post(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -239,7 +247,9 @@ class AsyncKnowledgeBasesResource(AsyncAPIResource):
                 f"Expected a non-empty value for `knowledge_base_uuid` but received {knowledge_base_uuid!r}"
             )
         return await self._post(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -278,7 +288,9 @@ class AsyncKnowledgeBasesResource(AsyncAPIResource):
                 f"Expected a non-empty value for `knowledge_base_uuid` but received {knowledge_base_uuid!r}"
             )
         return await self._delete(
-            f"/v2/genai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
+            f"/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{agent_uuid}/knowledge_bases/{knowledge_base_uuid}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),

{digitalocean_genai_sdk → gradientai}/resources/agents/versions.py

@@ -29,7 +29,7 @@ class VersionsResource(SyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return VersionsResourceWithRawResponse(self)
 
@@ -38,7 +38,7 @@ class VersionsResource(SyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return VersionsResourceWithStreamingResponse(self)
 
@@ -71,7 +71,9 @@ class VersionsResource(SyncAPIResource):
         if not path_uuid:
             raise ValueError(f"Expected a non-empty value for `path_uuid` but received {path_uuid!r}")
         return self._put(
-            f"/v2/gen-ai/agents/{path_uuid}/versions",
+            f"/v2/gen-ai/agents/{path_uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_uuid}/versions",
             body=maybe_transform(
                 {
                     "body_uuid": body_uuid,
@@ -118,7 +120,9 @@ class VersionsResource(SyncAPIResource):
         if not uuid:
             raise ValueError(f"Expected a non-empty value for `uuid` but received {uuid!r}")
         return self._get(
-            f"/v2/gen-ai/agents/{uuid}/versions",
+            f"/v2/gen-ai/agents/{uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{uuid}/versions",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -143,7 +147,7 @@ class AsyncVersionsResource(AsyncAPIResource):
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
         return AsyncVersionsResourceWithRawResponse(self)
 
@@ -152,7 +156,7 @@ class AsyncVersionsResource(AsyncAPIResource):
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
         return AsyncVersionsResourceWithStreamingResponse(self)
 
@@ -185,7 +189,9 @@ class AsyncVersionsResource(AsyncAPIResource):
         if not path_uuid:
             raise ValueError(f"Expected a non-empty value for `path_uuid` but received {path_uuid!r}")
         return await self._put(
-            f"/v2/gen-ai/agents/{path_uuid}/versions",
+            f"/v2/gen-ai/agents/{path_uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{path_uuid}/versions",
             body=await async_maybe_transform(
                 {
                     "body_uuid": body_uuid,
@@ -232,7 +238,9 @@ class AsyncVersionsResource(AsyncAPIResource):
         if not uuid:
             raise ValueError(f"Expected a non-empty value for `uuid` but received {uuid!r}")
         return await self._get(
-            f"/v2/gen-ai/agents/{uuid}/versions",
+            f"/v2/gen-ai/agents/{uuid}/versions"
+            if self._client._base_url_overridden
+            else f"https://api.digitalocean.com/v2/gen-ai/agents/{uuid}/versions",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,

gradientai/resources/chat/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "CompletionsResource",
+    "AsyncCompletionsResource",
+    "CompletionsResourceWithRawResponse",
+    "AsyncCompletionsResourceWithRawResponse",
+    "CompletionsResourceWithStreamingResponse",
+    "AsyncCompletionsResourceWithStreamingResponse",
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+]

gradientai/resources/chat/chat.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .completions import (
+    CompletionsResource,
+    AsyncCompletionsResource,
+    CompletionsResourceWithRawResponse,
+    AsyncCompletionsResourceWithRawResponse,
+    CompletionsResourceWithStreamingResponse,
+    AsyncCompletionsResourceWithStreamingResponse,
+)
+
+__all__ = ["ChatResource", "AsyncChatResource"]
+
+
+class ChatResource(SyncAPIResource):
+    @cached_property
+    def completions(self) -> CompletionsResource:
+        return CompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ChatResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
+        """
+        return ChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
+        """
+        return ChatResourceWithStreamingResponse(self)
+
+
+class AsyncChatResource(AsyncAPIResource):
+    @cached_property
+    def completions(self) -> AsyncCompletionsResource:
+        return AsyncCompletionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncChatResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncChatResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncChatResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
+        """
+        return AsyncChatResourceWithStreamingResponse(self)
+
+
+class ChatResourceWithRawResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithRawResponse:
+        return CompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithRawResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithRawResponse:
+        return AsyncCompletionsResourceWithRawResponse(self._chat.completions)
+
+
+class ChatResourceWithStreamingResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> CompletionsResourceWithStreamingResponse:
+        return CompletionsResourceWithStreamingResponse(self._chat.completions)
+
+
+class AsyncChatResourceWithStreamingResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResourceWithStreamingResponse:
+        return AsyncCompletionsResourceWithStreamingResponse(self._chat.completions)

digitalocean_genai_sdk/resources/chat.py → gradientai/resources/chat/completions.py

@@ -6,47 +6,47 @@ from typing import Dict, List, Union, Iterable, Optional
 
 import httpx
 
-from ..types import chat_create_completion_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 (
+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 (
     to_raw_response_wrapper,
     to_streamed_response_wrapper,
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .._base_client import make_request_options
-from ..types.chat_create_completion_response import ChatCreateCompletionResponse
+from ...types.chat import completion_create_params
+from ..._base_client import make_request_options
+from ...types.chat.completion_create_response import CompletionCreateResponse
 
-__all__ = ["ChatResource", "AsyncChatResource"]
+__all__ = ["CompletionsResource", "AsyncCompletionsResource"]
 
 
-class ChatResource(SyncAPIResource):
+class CompletionsResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> ChatResourceWithRawResponse:
+    def with_raw_response(self) -> CompletionsResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
-        return ChatResourceWithRawResponse(self)
+        return CompletionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> ChatResourceWithStreamingResponse:
+    def with_streaming_response(self) -> CompletionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
-        return ChatResourceWithStreamingResponse(self)
+        return CompletionsResourceWithStreamingResponse(self)
 
-    def create_completion(
+    def create(
         self,
         *,
-        messages: Iterable[chat_create_completion_params.Message],
+        messages: Iterable[completion_create_params.Message],
         model: str,
         frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
@@ -58,7 +58,7 @@ class ChatResource(SyncAPIResource):
         presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
         stream: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[chat_create_completion_params.StreamOptions] | NotGiven = NOT_GIVEN,
+        stream_options: Optional[completion_create_params.StreamOptions] | NotGiven = NOT_GIVEN,
         temperature: Optional[float] | NotGiven = NOT_GIVEN,
         top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
         top_p: Optional[float] | NotGiven = NOT_GIVEN,
@@ -69,7 +69,7 @@ class ChatResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ChatCreateCompletionResponse:
+    ) -> CompletionCreateResponse:
         """
         Creates a model response for the given chat conversation.
 
@@ -154,7 +154,9 @@ class ChatResource(SyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return self._post(
-            "/chat/completions",
+            "/chat/completions"
+            if self._client._base_url_overridden
+            else "https://inference.do-ai.run/v1/chat/completions",
             body=maybe_transform(
                 {
                     "messages": messages,
@@ -175,39 +177,39 @@ class ChatResource(SyncAPIResource):
                     "top_p": top_p,
                     "user": user,
                 },
-                chat_create_completion_params.ChatCreateCompletionParams,
+                completion_create_params.CompletionCreateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=CompletionCreateResponse,
         )
 
 
-class AsyncChatResource(AsyncAPIResource):
+class AsyncCompletionsResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncChatResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncCompletionsResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#accessing-raw-response-data-eg-headers
+        For more information, see https://www.github.com/digitalocean/gradientai-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncChatResourceWithRawResponse(self)
+        return AsyncCompletionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncChatResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncCompletionsResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
+        For more information, see https://www.github.com/digitalocean/gradientai-python#with_streaming_response
         """
-        return AsyncChatResourceWithStreamingResponse(self)
+        return AsyncCompletionsResourceWithStreamingResponse(self)
 
-    async def create_completion(
+    async def create(
         self,
         *,
-        messages: Iterable[chat_create_completion_params.Message],
+        messages: Iterable[completion_create_params.Message],
         model: str,
         frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
@@ -219,7 +221,7 @@ class AsyncChatResource(AsyncAPIResource):
         presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
         stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
         stream: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[chat_create_completion_params.StreamOptions] | NotGiven = NOT_GIVEN,
+        stream_options: Optional[completion_create_params.StreamOptions] | NotGiven = NOT_GIVEN,
         temperature: Optional[float] | NotGiven = NOT_GIVEN,
         top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
         top_p: Optional[float] | NotGiven = NOT_GIVEN,
@@ -230,7 +232,7 @@ class AsyncChatResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ChatCreateCompletionResponse:
+    ) -> CompletionCreateResponse:
         """
         Creates a model response for the given chat conversation.
 
@@ -315,7 +317,9 @@ class AsyncChatResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._post(
-            "/chat/completions",
+            "/chat/completions"
+            if self._client._base_url_overridden
+            else "https://inference.do-ai.run/v1/chat/completions",
             body=await async_maybe_transform(
                 {
                     "messages": messages,
@@ -336,46 +340,46 @@ class AsyncChatResource(AsyncAPIResource):
                     "top_p": top_p,
                     "user": user,
                 },
-                chat_create_completion_params.ChatCreateCompletionParams,
+                completion_create_params.CompletionCreateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=CompletionCreateResponse,
         )
 
 
-class ChatResourceWithRawResponse:
-    def __init__(self, chat: ChatResource) -> None:
-        self._chat = chat
+class CompletionsResourceWithRawResponse:
+    def __init__(self, completions: CompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = to_raw_response_wrapper(
-            chat.create_completion,
+        self.create = to_raw_response_wrapper(
+            completions.create,
         )
 
 
-class AsyncChatResourceWithRawResponse:
-    def __init__(self, chat: AsyncChatResource) -> None:
-        self._chat = chat
+class AsyncCompletionsResourceWithRawResponse:
+    def __init__(self, completions: AsyncCompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = async_to_raw_response_wrapper(
-            chat.create_completion,
+        self.create = async_to_raw_response_wrapper(
+            completions.create,
         )
 
 
-class ChatResourceWithStreamingResponse:
-    def __init__(self, chat: ChatResource) -> None:
-        self._chat = chat
+class CompletionsResourceWithStreamingResponse:
+    def __init__(self, completions: CompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = to_streamed_response_wrapper(
-            chat.create_completion,
+        self.create = to_streamed_response_wrapper(
+            completions.create,
         )
 
 
-class AsyncChatResourceWithStreamingResponse:
-    def __init__(self, chat: AsyncChatResource) -> None:
-        self._chat = chat
+class AsyncCompletionsResourceWithStreamingResponse:
+    def __init__(self, completions: AsyncCompletionsResource) -> None:
+        self._completions = completions
 
-        self.create_completion = async_to_streamed_response_wrapper(
-            chat.create_completion,
+        self.create = async_to_streamed_response_wrapper(
+            completions.create,
         )