vellum-ai 0.3.14__py3-none-any.whl → 0.3.15__py3-none-any.whl

vellum/resources/test_suite_runs/client.py

@@ -8,6 +8,7 @@ from ...core.api_error import ApiError
 from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
 from ...core.remove_none_from_dict import remove_none_from_dict
+from ...core.request_options import RequestOptions
 from ...types.paginated_test_suite_run_execution_list import PaginatedTestSuiteRunExecutionList
 from ...types.test_suite_run_exec_config_request import TestSuiteRunExecConfigRequest
 from ...types.test_suite_run_read import TestSuiteRunRead
@@ -26,25 +27,67 @@ class TestSuiteRunsClient:
         self._client_wrapper = client_wrapper
 
     def create(
-        self, *, test_suite_id: typing.Optional[str] = OMIT, exec_config: TestSuiteRunExecConfigRequest
+        self,
+        *,
+        test_suite_id: str,
+        exec_config: TestSuiteRunExecConfigRequest,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> TestSuiteRunRead:
         """
         Trigger a Test Suite and create a new Test Suite Run
 
         Parameters:
-            - test_suite_id: typing.Optional[str]. The ID of the Test Suite to run
+            - test_suite_id: str. The ID of the Test Suite to run
 
             - exec_config: TestSuiteRunExecConfigRequest. Configuration that defines how the Test Suite should be run
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from vellum import (
+            TestSuiteRunDeploymentReleaseTagExecConfigDataRequest,
+            TestSuiteRunExecConfigRequest_DeploymentReleaseTag,
+        )
+        from vellum.client import Vellum
+
+        client = Vellum(
+            api_key="YOUR_API_KEY",
+        )
+        client.test_suite_runs.create(
+            test_suite_id="string",
+            exec_config=TestSuiteRunExecConfigRequest_DeploymentReleaseTag(
+                data=TestSuiteRunDeploymentReleaseTagExecConfigDataRequest(
+                    deployment_id="string",
+                    tag="string",
+                ),
+                test_case_ids=["string"],
+            ),
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {"exec_config": exec_config}
-        if test_suite_id is not OMIT:
-            _request["test_suite_id"] = test_suite_id
         _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/test-suite-runs"),
-            json=jsonable_encoder(_request),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder({"test_suite_id": test_suite_id, "exec_config": exec_config})
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder({"test_suite_id": test_suite_id, "exec_config": exec_config}),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteRunRead, _response.json())  # type: ignore
@@ -54,12 +97,14 @@ class TestSuiteRunsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def retrieve(self, id: str) -> TestSuiteRunRead:
+    def retrieve(self, id: str, *, request_options: typing.Optional[RequestOptions] = None) -> TestSuiteRunRead:
         """
         Retrieve a specific Test Suite Run by ID
 
         Parameters:
             - id: str. A UUID string identifying this test suite run.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import Vellum
 
@@ -72,9 +117,25 @@ class TestSuiteRunsClient:
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{id}"),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{jsonable_encoder(id)}"
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteRunRead, _response.json())  # type: ignore
@@ -84,8 +145,13 @@ class TestSuiteRunsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def list_test_suite_run_executions(
-        self, id: str, *, limit: typing.Optional[int] = None, offset: typing.Optional[int] = None
+    def list_executions(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> PaginatedTestSuiteRunExecutionList:
         """
         Parameters:
@@ -94,24 +160,50 @@ class TestSuiteRunsClient:
             - limit: typing.Optional[int]. Number of results to return per page.
 
             - offset: typing.Optional[int]. The initial index from which to return the results.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import Vellum
 
         client = Vellum(
             api_key="YOUR_API_KEY",
         )
-        client.test_suite_runs.list_test_suite_run_executions(
+        client.test_suite_runs.list_executions(
             id="id",
         )
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{id}/executions"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suite-runs/{jsonable_encoder(id)}/executions",
+            ),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "limit": limit,
+                        "offset": offset,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            params=remove_none_from_dict({"limit": limit, "offset": offset}),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(PaginatedTestSuiteRunExecutionList, _response.json())  # type: ignore
@@ -127,25 +219,67 @@ class AsyncTestSuiteRunsClient:
         self._client_wrapper = client_wrapper
 
     async def create(
-        self, *, test_suite_id: typing.Optional[str] = OMIT, exec_config: TestSuiteRunExecConfigRequest
+        self,
+        *,
+        test_suite_id: str,
+        exec_config: TestSuiteRunExecConfigRequest,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> TestSuiteRunRead:
         """
         Trigger a Test Suite and create a new Test Suite Run
 
         Parameters:
-            - test_suite_id: typing.Optional[str]. The ID of the Test Suite to run
+            - test_suite_id: str. The ID of the Test Suite to run
 
             - exec_config: TestSuiteRunExecConfigRequest. Configuration that defines how the Test Suite should be run
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
+        ---
+        from vellum import (
+            TestSuiteRunDeploymentReleaseTagExecConfigDataRequest,
+            TestSuiteRunExecConfigRequest_DeploymentReleaseTag,
+        )
+        from vellum.client import AsyncVellum
+
+        client = AsyncVellum(
+            api_key="YOUR_API_KEY",
+        )
+        await client.test_suite_runs.create(
+            test_suite_id="string",
+            exec_config=TestSuiteRunExecConfigRequest_DeploymentReleaseTag(
+                data=TestSuiteRunDeploymentReleaseTagExecConfigDataRequest(
+                    deployment_id="string",
+                    tag="string",
+                ),
+                test_case_ids=["string"],
+            ),
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {"exec_config": exec_config}
-        if test_suite_id is not OMIT:
-            _request["test_suite_id"] = test_suite_id
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/test-suite-runs"),
-            json=jsonable_encoder(_request),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder({"test_suite_id": test_suite_id, "exec_config": exec_config})
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder({"test_suite_id": test_suite_id, "exec_config": exec_config}),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteRunRead, _response.json())  # type: ignore
@@ -155,12 +289,14 @@ class AsyncTestSuiteRunsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def retrieve(self, id: str) -> TestSuiteRunRead:
+    async def retrieve(self, id: str, *, request_options: typing.Optional[RequestOptions] = None) -> TestSuiteRunRead:
         """
         Retrieve a specific Test Suite Run by ID
 
         Parameters:
             - id: str. A UUID string identifying this test suite run.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import AsyncVellum
 
@@ -173,9 +309,25 @@ class AsyncTestSuiteRunsClient:
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{id}"),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{jsonable_encoder(id)}"
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteRunRead, _response.json())  # type: ignore
@@ -185,8 +337,13 @@ class AsyncTestSuiteRunsClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def list_test_suite_run_executions(
-        self, id: str, *, limit: typing.Optional[int] = None, offset: typing.Optional[int] = None
+    async def list_executions(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> PaginatedTestSuiteRunExecutionList:
         """
         Parameters:
@@ -195,24 +352,50 @@ class AsyncTestSuiteRunsClient:
             - limit: typing.Optional[int]. Number of results to return per page.
 
             - offset: typing.Optional[int]. The initial index from which to return the results.
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import AsyncVellum
 
         client = AsyncVellum(
             api_key="YOUR_API_KEY",
         )
-        await client.test_suite_runs.list_test_suite_run_executions(
+        await client.test_suite_runs.list_executions(
             id="id",
         )
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suite-runs/{id}/executions"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suite-runs/{jsonable_encoder(id)}/executions",
+            ),
+            params=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        "limit": limit,
+                        "offset": offset,
+                        **(
+                            request_options.get("additional_query_parameters", {})
+                            if request_options is not None
+                            else {}
+                        ),
+                    }
+                )
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            params=remove_none_from_dict({"limit": limit, "offset": offset}),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(PaginatedTestSuiteRunExecutionList, _response.json())  # type: ignore

vellum/resources/test_suites/client.py

@@ -7,6 +7,8 @@ from json.decoder import JSONDecodeError
 from ...core.api_error import ApiError
 from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
+from ...core.remove_none_from_dict import remove_none_from_dict
+from ...core.request_options import RequestOptions
 from ...types.named_test_case_variable_value_request import NamedTestCaseVariableValueRequest
 from ...types.test_suite_test_case import TestSuiteTestCase
 
@@ -29,8 +31,9 @@ class TestSuitesClient:
         *,
         upsert_test_suite_test_case_request_id: typing.Optional[str] = OMIT,
         label: typing.Optional[str] = OMIT,
-        input_values: typing.List[NamedTestCaseVariableValueRequest],
-        evaluation_values: typing.List[NamedTestCaseVariableValueRequest],
+        input_values: typing.Sequence[NamedTestCaseVariableValueRequest],
+        evaluation_values: typing.Sequence[NamedTestCaseVariableValueRequest],
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> TestSuiteTestCase:
         """
         Upserts a new test case for a test suite, keying off of the optionally provided test case id.
@@ -48,9 +51,11 @@ class TestSuitesClient:
 
             - label: typing.Optional[str].
 
-            - input_values: typing.List[NamedTestCaseVariableValueRequest].
+            - input_values: typing.Sequence[NamedTestCaseVariableValueRequest].
 
-            - evaluation_values: typing.List[NamedTestCaseVariableValueRequest].
+            - evaluation_values: typing.Sequence[NamedTestCaseVariableValueRequest].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import Vellum
 
@@ -71,11 +76,31 @@ class TestSuitesClient:
         _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suites/{id}/test-cases"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suites/{jsonable_encoder(id)}/test-cases",
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder(_request)
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            json=jsonable_encoder(_request),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteTestCase, _response.json())  # type: ignore
@@ -85,7 +110,9 @@ class TestSuitesClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def delete_test_suite_test_case(self, id: str, test_case_id: str) -> None:
+    def delete_test_suite_test_case(
+        self, id: str, test_case_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> None:
         """
         Deletes an existing test case for a test suite, keying off of the test case id.
 
@@ -93,6 +120,8 @@ class TestSuitesClient:
             - id: str. A UUID string identifying this test suite.
 
             - test_case_id: str. An id identifying the test case that you'd like to delete
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import Vellum
 
@@ -107,10 +136,25 @@ class TestSuitesClient:
         _response = self._client_wrapper.httpx_client.request(
             "DELETE",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suites/{id}/test-cases/{test_case_id}"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suites/{jsonable_encoder(id)}/test-cases/{jsonable_encoder(test_case_id)}",
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return
@@ -131,8 +175,9 @@ class AsyncTestSuitesClient:
         *,
         upsert_test_suite_test_case_request_id: typing.Optional[str] = OMIT,
         label: typing.Optional[str] = OMIT,
-        input_values: typing.List[NamedTestCaseVariableValueRequest],
-        evaluation_values: typing.List[NamedTestCaseVariableValueRequest],
+        input_values: typing.Sequence[NamedTestCaseVariableValueRequest],
+        evaluation_values: typing.Sequence[NamedTestCaseVariableValueRequest],
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> TestSuiteTestCase:
         """
         Upserts a new test case for a test suite, keying off of the optionally provided test case id.
@@ -150,9 +195,11 @@ class AsyncTestSuitesClient:
 
             - label: typing.Optional[str].
 
-            - input_values: typing.List[NamedTestCaseVariableValueRequest].
+            - input_values: typing.Sequence[NamedTestCaseVariableValueRequest].
 
-            - evaluation_values: typing.List[NamedTestCaseVariableValueRequest].
+            - evaluation_values: typing.Sequence[NamedTestCaseVariableValueRequest].
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import AsyncVellum
 
@@ -173,11 +220,31 @@ class AsyncTestSuitesClient:
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suites/{id}/test-cases"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suites/{jsonable_encoder(id)}/test-cases",
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            json=jsonable_encoder(_request)
+            if request_options is None or request_options.get("additional_body_parameters") is None
+            else {
+                **jsonable_encoder(_request),
+                **(jsonable_encoder(remove_none_from_dict(request_options.get("additional_body_parameters", {})))),
+            },
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            json=jsonable_encoder(_request),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(TestSuiteTestCase, _response.json())  # type: ignore
@@ -187,7 +254,9 @@ class AsyncTestSuitesClient:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def delete_test_suite_test_case(self, id: str, test_case_id: str) -> None:
+    async def delete_test_suite_test_case(
+        self, id: str, test_case_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> None:
         """
         Deletes an existing test case for a test suite, keying off of the test case id.
 
@@ -195,6 +264,8 @@ class AsyncTestSuitesClient:
             - id: str. A UUID string identifying this test suite.
 
             - test_case_id: str. An id identifying the test case that you'd like to delete
+
+            - request_options: typing.Optional[RequestOptions]. Request-specific configuration.
         ---
         from vellum.client import AsyncVellum
 
@@ -209,10 +280,25 @@ class AsyncTestSuitesClient:
         _response = await self._client_wrapper.httpx_client.request(
             "DELETE",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_environment().default}/", f"v1/test-suites/{id}/test-cases/{test_case_id}"
+                f"{self._client_wrapper.get_environment().default}/",
+                f"v1/test-suites/{jsonable_encoder(id)}/test-cases/{jsonable_encoder(test_case_id)}",
+            ),
+            params=jsonable_encoder(
+                request_options.get("additional_query_parameters") if request_options is not None else None
+            ),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self._client_wrapper.get_headers(),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
             ),
-            headers=self._client_wrapper.get_headers(),
-            timeout=None,
+            timeout=request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self._client_wrapper.get_timeout(),
+            retries=0,
+            max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
             return