feat(api): update via SDK Studio

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 105
+configured_endpoints: 106
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/llamastack%2Fllama-stack-client-ab9c9bf2527d3b4179e2bc3e6495c64d43c42b2ea8dc1a55d472986e1a1430a0.yml
 openapi_spec_hash: b93c85fb747e3c29134451d2f364ce8b
-config_hash: 0394c2b14022becb0352c36afcdfbafe
+config_hash: b0cd3ed9be70b0310bc685a4014eb0a5

api.md

@@ -463,6 +463,7 @@ from llama_stack_client.types import OpenAIModerationsResponse, RunShieldRespons
 
 Methods:
 
+- <code title="post /v1/openai/v1/moderations">client.safety.<a href="./src/llama_stack_client/resources/safety.py">openai_moderations</a>(\*\*<a href="src/llama_stack_client/types/safety_openai_moderations_params.py">params</a>) -> <a href="./src/llama_stack_client/types/openai_moderations_response.py">OpenAIModerationsResponse</a></code>
 - <code title="post /v1/safety/run-shield">client.safety.<a href="./src/llama_stack_client/resources/safety.py">run_shield</a>(\*\*<a href="src/llama_stack_client/types/safety_run_shield_params.py">params</a>) -> <a href="./src/llama_stack_client/types/run_shield_response.py">RunShieldResponse</a></code>
 
 # Shields

src/llama_stack_client/resources/safety.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union, Iterable
+from typing import Dict, List, Union, Iterable
 
 import httpx
 
-from ..types import safety_run_shield_params
+from ..types import safety_run_shield_params, safety_openai_moderations_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -20,6 +20,7 @@
 from .._base_client import make_request_options
 from ..types.run_shield_response import RunShieldResponse
 from ..types.shared_params.message import Message
+from ..types.openai_moderations_response import OpenAIModerationsResponse
 
 __all__ = ["SafetyResource", "AsyncSafetyResource"]
 
@@ -44,6 +45,50 @@ def with_streaming_response(self) -> SafetyResourceWithStreamingResponse:
         """
         return SafetyResourceWithStreamingResponse(self)
 
+    def openai_moderations(
+        self,
+        *,
+        input: Union[str, List[str]],
+        model: str | 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,
+    ) -> OpenAIModerationsResponse:
+        """
+        Classifies if text and/or image inputs are potentially harmful.
+
+        Args:
+          input: Input (or inputs) to classify. Can be a single string, an array of strings, or
+              an array of multi-modal input objects similar to other models.
+
+          model: The content moderation model you would like to use.
+
+          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(
+            "/v1/openai/v1/moderations",
+            body=maybe_transform(
+                {
+                    "input": input,
+                    "model": model,
+                },
+                safety_openai_moderations_params.SafetyOpenAIModerationsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OpenAIModerationsResponse,
+        )
+
     def run_shield(
         self,
         *,
@@ -112,6 +157,50 @@ def with_streaming_response(self) -> AsyncSafetyResourceWithStreamingResponse:
         """
         return AsyncSafetyResourceWithStreamingResponse(self)
 
+    async def openai_moderations(
+        self,
+        *,
+        input: Union[str, List[str]],
+        model: str | 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,
+    ) -> OpenAIModerationsResponse:
+        """
+        Classifies if text and/or image inputs are potentially harmful.
+
+        Args:
+          input: Input (or inputs) to classify. Can be a single string, an array of strings, or
+              an array of multi-modal input objects similar to other models.
+
+          model: The content moderation model you would like to use.
+
+          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(
+            "/v1/openai/v1/moderations",
+            body=await async_maybe_transform(
+                {
+                    "input": input,
+                    "model": model,
+                },
+                safety_openai_moderations_params.SafetyOpenAIModerationsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OpenAIModerationsResponse,
+        )
+
     async def run_shield(
         self,
         *,
@@ -164,6 +253,9 @@ class SafetyResourceWithRawResponse:
     def __init__(self, safety: SafetyResource) -> None:
         self._safety = safety
 
+        self.openai_moderations = to_raw_response_wrapper(
+            safety.openai_moderations,
+        )
         self.run_shield = to_raw_response_wrapper(
             safety.run_shield,
         )
@@ -173,6 +265,9 @@ class AsyncSafetyResourceWithRawResponse:
     def __init__(self, safety: AsyncSafetyResource) -> None:
         self._safety = safety
 
+        self.openai_moderations = async_to_raw_response_wrapper(
+            safety.openai_moderations,
+        )
         self.run_shield = async_to_raw_response_wrapper(
             safety.run_shield,
         )
@@ -182,6 +277,9 @@ class SafetyResourceWithStreamingResponse:
     def __init__(self, safety: SafetyResource) -> None:
         self._safety = safety
 
+        self.openai_moderations = to_streamed_response_wrapper(
+            safety.openai_moderations,
+        )
         self.run_shield = to_streamed_response_wrapper(
             safety.run_shield,
         )
@@ -191,6 +289,9 @@ class AsyncSafetyResourceWithStreamingResponse:
     def __init__(self, safety: AsyncSafetyResource) -> None:
         self._safety = safety
 
+        self.openai_moderations = async_to_streamed_response_wrapper(
+            safety.openai_moderations,
+        )
         self.run_shield = async_to_streamed_response_wrapper(
             safety.run_shield,
         )

src/llama_stack_client/types/__init__.py

@@ -133,6 +133,7 @@
 from .inference_completion_params import InferenceCompletionParams as InferenceCompletionParams
 from .inference_embeddings_params import InferenceEmbeddingsParams as InferenceEmbeddingsParams
 from .list_vector_stores_response import ListVectorStoresResponse as ListVectorStoresResponse
+from .openai_moderations_response import OpenAIModerationsResponse as OpenAIModerationsResponse
 from .telemetry_get_span_response import TelemetryGetSpanResponse as TelemetryGetSpanResponse
 from .vector_db_register_response import VectorDBRegisterResponse as VectorDBRegisterResponse
 from .vector_db_retrieve_response import VectorDBRetrieveResponse as VectorDBRetrieveResponse
@@ -151,6 +152,7 @@
 from .tool_runtime_invoke_tool_params import ToolRuntimeInvokeToolParams as ToolRuntimeInvokeToolParams
 from .inference_chat_completion_params import InferenceChatCompletionParams as InferenceChatCompletionParams
 from .list_post_training_jobs_response import ListPostTrainingJobsResponse as ListPostTrainingJobsResponse
+from .safety_openai_moderations_params import SafetyOpenAIModerationsParams as SafetyOpenAIModerationsParams
 from .scoring_function_register_params import ScoringFunctionRegisterParams as ScoringFunctionRegisterParams
 from .telemetry_get_span_tree_response import TelemetryGetSpanTreeResponse as TelemetryGetSpanTreeResponse
 from .tool_runtime_list_tools_response import ToolRuntimeListToolsResponse as ToolRuntimeListToolsResponse

src/llama_stack_client/types/openai_moderations_response.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List
+
+from .._models import BaseModel
+
+__all__ = ["OpenAIModerationsResponse", "Result"]
+
+
+class Result(BaseModel):
+    categories: Dict[str, bool]
+    """A list of the categories, and whether they are flagged or not."""
+
+    category_applied_input_types: Dict[str, List[str]]
+
+    category_messages: Dict[str, str]
+
+    category_scores: Dict[str, float]
+    """A list of the categories along with their scores as predicted by model."""
+
+    flagged: bool
+    """Whether any of the below categories are flagged."""
+
+
+class OpenAIModerationsResponse(BaseModel):
+    id: str
+    """The unique identifier for the moderation request."""
+
+    model: str
+    """The model used to generate the moderation results."""
+
+    results: List[Result]
+    """A list of moderation objects"""

src/llama_stack_client/types/safety_openai_moderations_params.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from typing_extensions import Required, TypedDict
+
+__all__ = ["SafetyOpenAIModerationsParams"]
+
+
+class SafetyOpenAIModerationsParams(TypedDict, total=False):
+    input: Required[Union[str, List[str]]]
+    """Input (or inputs) to classify.
+
+    Can be a single string, an array of strings, or an array of multi-modal input
+    objects similar to other models.
+    """
+
+    model: str
+    """The content moderation model you would like to use."""

tests/api_resources/test_safety.py

@@ -9,14 +9,56 @@
 
 from tests.utils import assert_matches_type
 from llama_stack_client import LlamaStackClient, AsyncLlamaStackClient
-from llama_stack_client.types import RunShieldResponse
+from llama_stack_client.types import (
+    RunShieldResponse,
+    OpenAIModerationsResponse,
+)
 
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
 
 class TestSafety:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
+    @parametrize
+    def test_method_openai_moderations(self, client: LlamaStackClient) -> None:
+        safety = client.safety.openai_moderations(
+            input="string",
+        )
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    def test_method_openai_moderations_with_all_params(self, client: LlamaStackClient) -> None:
+        safety = client.safety.openai_moderations(
+            input="string",
+            model="model",
+        )
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    def test_raw_response_openai_moderations(self, client: LlamaStackClient) -> None:
+        response = client.safety.with_raw_response.openai_moderations(
+            input="string",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        safety = response.parse()
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    def test_streaming_response_openai_moderations(self, client: LlamaStackClient) -> None:
+        with client.safety.with_streaming_response.openai_moderations(
+            input="string",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            safety = response.parse()
+            assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
     @parametrize
     def test_method_run_shield(self, client: LlamaStackClient) -> None:
         safety = client.safety.run_shield(
@@ -75,6 +117,45 @@ class TestAsyncSafety:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
+    @parametrize
+    async def test_method_openai_moderations(self, async_client: AsyncLlamaStackClient) -> None:
+        safety = await async_client.safety.openai_moderations(
+            input="string",
+        )
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    async def test_method_openai_moderations_with_all_params(self, async_client: AsyncLlamaStackClient) -> None:
+        safety = await async_client.safety.openai_moderations(
+            input="string",
+            model="model",
+        )
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    async def test_raw_response_openai_moderations(self, async_client: AsyncLlamaStackClient) -> None:
+        response = await async_client.safety.with_raw_response.openai_moderations(
+            input="string",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        safety = await response.parse()
+        assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_openai_moderations(self, async_client: AsyncLlamaStackClient) -> None:
+        async with async_client.safety.with_streaming_response.openai_moderations(
+            input="string",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            safety = await response.parse()
+            assert_matches_type(OpenAIModerationsResponse, safety, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
     @parametrize
     async def test_method_run_shield(self, async_client: AsyncLlamaStackClient) -> None:
         safety = await async_client.safety.run_shield(