casedev 0.1.0__py3-none-any.whl

casedev/resources/llm/llm.py

@@ -0,0 +1,192 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .v1.v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from ..._types import Body, Query, Headers, NoneType, NotGiven, not_given
+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
+
+__all__ = ["LlmResource", "AsyncLlmResource"]
+
+
+class LlmResource(SyncAPIResource):
+    @cached_property
+    def v1(self) -> V1Resource:
+        return V1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> LlmResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return LlmResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> LlmResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return LlmResourceWithStreamingResponse(self)
+
+    def get_config(
+        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,
+    ) -> None:
+        """
+        Retrieves the AI Gateway configuration including all available language models
+        and their specifications. This endpoint returns model information compatible
+        with the Vercel AI SDK Gateway format, making it easy to integrate with existing
+        AI applications.
+
+        Use this endpoint to:
+
+        - Discover available language models
+        - Get model specifications and pricing
+        - Configure AI SDK clients
+        - Build model selection interfaces
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            "/llm/config",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncLlmResource(AsyncAPIResource):
+    @cached_property
+    def v1(self) -> AsyncV1Resource:
+        return AsyncV1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncLlmResourceWithRawResponse:
+        """
+        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/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncLlmResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncLlmResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncLlmResourceWithStreamingResponse(self)
+
+    async def get_config(
+        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,
+    ) -> None:
+        """
+        Retrieves the AI Gateway configuration including all available language models
+        and their specifications. This endpoint returns model information compatible
+        with the Vercel AI SDK Gateway format, making it easy to integrate with existing
+        AI applications.
+
+        Use this endpoint to:
+
+        - Discover available language models
+        - Get model specifications and pricing
+        - Configure AI SDK clients
+        - Build model selection interfaces
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            "/llm/config",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class LlmResourceWithRawResponse:
+    def __init__(self, llm: LlmResource) -> None:
+        self._llm = llm
+
+        self.get_config = to_raw_response_wrapper(
+            llm.get_config,
+        )
+
+    @cached_property
+    def v1(self) -> V1ResourceWithRawResponse:
+        return V1ResourceWithRawResponse(self._llm.v1)
+
+
+class AsyncLlmResourceWithRawResponse:
+    def __init__(self, llm: AsyncLlmResource) -> None:
+        self._llm = llm
+
+        self.get_config = async_to_raw_response_wrapper(
+            llm.get_config,
+        )
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithRawResponse:
+        return AsyncV1ResourceWithRawResponse(self._llm.v1)
+
+
+class LlmResourceWithStreamingResponse:
+    def __init__(self, llm: LlmResource) -> None:
+        self._llm = llm
+
+        self.get_config = to_streamed_response_wrapper(
+            llm.get_config,
+        )
+
+    @cached_property
+    def v1(self) -> V1ResourceWithStreamingResponse:
+        return V1ResourceWithStreamingResponse(self._llm.v1)
+
+
+class AsyncLlmResourceWithStreamingResponse:
+    def __init__(self, llm: AsyncLlmResource) -> None:
+        self._llm = llm
+
+        self.get_config = async_to_streamed_response_wrapper(
+            llm.get_config,
+        )
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithStreamingResponse:
+        return AsyncV1ResourceWithStreamingResponse(self._llm.v1)

casedev/resources/llm/v1/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+    "V1Resource",
+    "AsyncV1Resource",
+    "V1ResourceWithRawResponse",
+    "AsyncV1ResourceWithRawResponse",
+    "V1ResourceWithStreamingResponse",
+    "AsyncV1ResourceWithStreamingResponse",
+]

casedev/resources/llm/v1/chat.py

@@ -0,0 +1,243 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import httpx
+
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+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.llm.v1 import chat_create_completion_params
+from ....types.llm.v1.chat_create_completion_response import ChatCreateCompletionResponse
+
+__all__ = ["ChatResource", "AsyncChatResource"]
+
+
+class ChatResource(SyncAPIResource):
+    @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/CaseMark/casedev-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/CaseMark/casedev-python#with_streaming_response
+        """
+        return ChatResourceWithStreamingResponse(self)
+
+    def create_completion(
+        self,
+        *,
+        messages: Iterable[chat_create_completion_params.Message],
+        frequency_penalty: float | Omit = omit,
+        max_tokens: int | Omit = omit,
+        model: str | Omit = omit,
+        presence_penalty: float | Omit = omit,
+        stream: bool | Omit = omit,
+        temperature: float | Omit = omit,
+        top_p: float | Omit = omit,
+        # 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,
+    ) -> ChatCreateCompletionResponse:
+        """Create a completion for the provided prompt and parameters.
+
+        Compatible with
+        OpenAI's chat completions API. Supports 40+ models including GPT-4, Claude,
+        Gemini, and CaseMark legal AI models. Includes streaming support, token
+        counting, and usage tracking.
+
+        Args:
+          messages: List of messages comprising the conversation
+
+          frequency_penalty: Frequency penalty parameter
+
+          max_tokens: Maximum number of tokens to generate
+
+          model: Model to use for completion. Defaults to casemark-core-1 if not specified
+
+          presence_penalty: Presence penalty parameter
+
+          stream: Whether to stream back partial progress
+
+          temperature: Sampling temperature between 0 and 2
+
+          top_p: Nucleus sampling parameter
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/llm/v1/chat/completions",
+            body=maybe_transform(
+                {
+                    "messages": messages,
+                    "frequency_penalty": frequency_penalty,
+                    "max_tokens": max_tokens,
+                    "model": model,
+                    "presence_penalty": presence_penalty,
+                    "stream": stream,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                },
+                chat_create_completion_params.ChatCreateCompletionParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatCreateCompletionResponse,
+        )
+
+
+class AsyncChatResource(AsyncAPIResource):
+    @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/CaseMark/casedev-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/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncChatResourceWithStreamingResponse(self)
+
+    async def create_completion(
+        self,
+        *,
+        messages: Iterable[chat_create_completion_params.Message],
+        frequency_penalty: float | Omit = omit,
+        max_tokens: int | Omit = omit,
+        model: str | Omit = omit,
+        presence_penalty: float | Omit = omit,
+        stream: bool | Omit = omit,
+        temperature: float | Omit = omit,
+        top_p: float | Omit = omit,
+        # 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,
+    ) -> ChatCreateCompletionResponse:
+        """Create a completion for the provided prompt and parameters.
+
+        Compatible with
+        OpenAI's chat completions API. Supports 40+ models including GPT-4, Claude,
+        Gemini, and CaseMark legal AI models. Includes streaming support, token
+        counting, and usage tracking.
+
+        Args:
+          messages: List of messages comprising the conversation
+
+          frequency_penalty: Frequency penalty parameter
+
+          max_tokens: Maximum number of tokens to generate
+
+          model: Model to use for completion. Defaults to casemark-core-1 if not specified
+
+          presence_penalty: Presence penalty parameter
+
+          stream: Whether to stream back partial progress
+
+          temperature: Sampling temperature between 0 and 2
+
+          top_p: Nucleus sampling parameter
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/llm/v1/chat/completions",
+            body=await async_maybe_transform(
+                {
+                    "messages": messages,
+                    "frequency_penalty": frequency_penalty,
+                    "max_tokens": max_tokens,
+                    "model": model,
+                    "presence_penalty": presence_penalty,
+                    "stream": stream,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                },
+                chat_create_completion_params.ChatCreateCompletionParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatCreateCompletionResponse,
+        )
+
+
+class ChatResourceWithRawResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+        self.create_completion = to_raw_response_wrapper(
+            chat.create_completion,
+        )
+
+
+class AsyncChatResourceWithRawResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+        self.create_completion = async_to_raw_response_wrapper(
+            chat.create_completion,
+        )
+
+
+class ChatResourceWithStreamingResponse:
+    def __init__(self, chat: ChatResource) -> None:
+        self._chat = chat
+
+        self.create_completion = to_streamed_response_wrapper(
+            chat.create_completion,
+        )
+
+
+class AsyncChatResourceWithStreamingResponse:
+    def __init__(self, chat: AsyncChatResource) -> None:
+        self._chat = chat
+
+        self.create_completion = async_to_streamed_response_wrapper(
+            chat.create_completion,
+        )