Repository: ArcadeAI/arcade-py (language: python)

Issue:
Remove old test file



Discussion / hints:

Fix patch:
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index aaf968a..b56c3d0 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "0.1.0-alpha.3"
+  ".": "0.1.0-alpha.4"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e938286..6bf45e8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.0-alpha.4 (2024-10-14)
+
+Full Changelog: [v0.1.0-alpha.3...v0.1.0-alpha.4](https://github.com/ArcadeAI/arcade-py/compare/v0.1.0-alpha.3...v0.1.0-alpha.4)
+
+### Features
+
+* **api:** api update ([#17](https://github.com/ArcadeAI/arcade-py/issues/17)) ([c3efdc4](https://github.com/ArcadeAI/arcade-py/commit/c3efdc4cbfa3eb9e6bdd173c28ea02701ed02598))
+
 ## 0.1.0-alpha.3 (2024-10-14)
 
 Full Changelog: [v0.1.0-alpha.2...v0.1.0-alpha.3](https://github.com/ArcadeAI/arcade-py/compare/v0.1.0-alpha.2...v0.1.0-alpha.3)
diff --git a/README.md b/README.md
index af5ae20..c718f1b 100644
--- a/README.md
+++ b/README.md
@@ -15,13 +15,10 @@ The REST API documentation can be found on [arcade-ai.com](https://arcade-ai.com
 ## Installation
 
 ```sh
-# install from the production repo
-pip install git+ssh://git@github.com/ArcadeAI/arcade-py.git
+# install from PyPI
+pip install --pre arcadepy
 ```
 
-> [!NOTE]
-> Once this package is [published to PyPI](https://app.stainlessapi.com/docs/guides/publish), this will become: `pip install --pre arcadepy`
-
 ## Usage
 
 The full API of this library can be found in [api.md](api.md).
diff --git a/pyproject.toml b/pyproject.toml
index 962dac2..e19fc23 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "arcadepy"
-version = "0.1.0-alpha.3"
+version = "0.1.0-alpha.4"
 description = "The official Python library for the Arcade API"
 dynamic = ["readme"]
 license = "Apache-2.0"
diff --git a/src/arcadepy/_version.py b/src/arcadepy/_version.py
index cac8d22..bbfd32a 100644
--- a/src/arcadepy/_version.py
+++ b/src/arcadepy/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "arcadepy"
-__version__ = "0.1.0-alpha.3"  # x-release-please-version
+__version__ = "0.1.0-alpha.4"  # x-release-please-version


Test patch:
diff --git a/tests/api_resources/test_authorization.py b/tests/api_resources/test_authorization.py
deleted file mode 100644
index 32ce787..0000000
--- a/tests/api_resources/test_authorization.py
+++ /dev/null
@@ -1,196 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, cast
-
-import pytest
-
-from tests.utils import assert_matches_type
-from arcade_engine import ArcadeEngine, AsyncArcadeEngine
-from arcade_engine.types.shared import AuthorizationResponse
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestAuthorization:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    def test_method_authorize(self, client: ArcadeEngine) -> None:
-        authorization = client.authorization.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_method_authorize_with_all_params(self, client: ArcadeEngine) -> None:
-        authorization = client.authorization.authorize(
-            auth_requirement={
-                "provider": "provider",
-                "oauth2": {
-                    "authority": "authority",
-                    "scopes": ["string", "string", "string"],
-                },
-            },
-            user_id="user_id",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_raw_response_authorize(self, client: ArcadeEngine) -> None:
-        response = client.authorization.with_raw_response.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        )
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        authorization = response.parse()
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_streaming_response_authorize(self, client: ArcadeEngine) -> None:
-        with client.authorization.with_streaming_response.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            authorization = response.parse()
-            assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-    @parametrize
-    def test_method_status(self, client: ArcadeEngine) -> None:
-        authorization = client.authorization.status(
-            authorization_id="authorizationID",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_method_status_with_all_params(self, client: ArcadeEngine) -> None:
-        authorization = client.authorization.status(
-            authorization_id="authorizationID",
-            scopes="scopes",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_raw_response_status(self, client: ArcadeEngine) -> None:
-        response = client.authorization.with_raw_response.status(
-            authorization_id="authorizationID",
-        )
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        authorization = response.parse()
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    def test_streaming_response_status(self, client: ArcadeEngine) -> None:
-        with client.authorization.with_streaming_response.status(
-            authorization_id="authorizationID",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            authorization = response.parse()
-            assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncAuthorization:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    async def test_method_authorize(self, async_client: AsyncArcadeEngine) -> None:
-        authorization = await async_client.authorization.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_method_authorize_with_all_params(self, async_client: AsyncArcadeEngine) -> None:
-        authorization = await async_client.authorization.authorize(
-            auth_requirement={
-                "provider": "provider",
-                "oauth2": {
-                    "authority": "authority",
-                    "scopes": ["string", "string", "string"],
-                },
-            },
-            user_id="user_id",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_raw_response_authorize(self, async_client: AsyncArcadeEngine) -> None:
-        response = await async_client.authorization.with_raw_response.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        )
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        authorization = await response.parse()
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_authorize(self, async_client: AsyncArcadeEngine) -> None:
-        async with async_client.authorization.with_streaming_response.authorize(
-            auth_requirement={"provider": "provider"},
-            user_id="user_id",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            authorization = await response.parse()
-            assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-    @parametrize
-    async def test_method_status(self, async_client: AsyncArcadeEngine) -> None:
-        authorization = await async_client.authorization.status(
-            authorization_id="authorizationID",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_method_status_with_all_params(self, async_client: AsyncArcadeEngine) -> None:
-        authorization = await async_client.authorization.status(
-            authorization_id="authorizationID",
-            scopes="scopes",
-        )
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_raw_response_status(self, async_client: AsyncArcadeEngine) -> None:
-        response = await async_client.authorization.with_raw_response.status(
-            authorization_id="authorizationID",
-        )
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        authorization = await response.parse()
-        assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_status(self, async_client: AsyncArcadeEngine) -> None:
-        async with async_client.authorization.with_streaming_response.status(
-            authorization_id="authorizationID",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            authorization = await response.parse()
-            assert_matches_type(AuthorizationResponse, authorization, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_chat.py b/tests/api_resources/test_chat.py
deleted file mode 100644
index 0b6b965..0000000
--- a/tests/api_resources/test_chat.py
+++ /dev/null
@@ -1,318 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, cast
-
-import pytest
-
-from arcadepy import Arcade, AsyncArcade
-from tests.utils import assert_matches_type
-from arcadepy.types import ChatResponse
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestChat:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    def test_method_completions(self, client: Arcade) -> None:
-        chat = client.chat.completions()
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    def test_method_completions_with_all_params(self, client: Arcade) -> None:
-        chat = client.chat.completions(
-            frequency_penalty=0,
-            logit_bias={"foo": 0},
-            logprobs=True,
-            max_tokens=0,
-            messages=[
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-            ],
-            model="model",
-            n=0,
-            parallel_tool_calls=True,
-            presence_penalty=0,
-            response_format="json_object",
-            seed=0,
-            stop=["string", "string", "string"],
-            stream=True,
-            stream_options={"include_usage": True},
-            temperature=0,
-            tool_choice="",
-            tools={},
-            top_logprobs=0,
-            top_p=0,
-            user="user",
-        )
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    def test_raw_response_completions(self, client: Arcade) -> None:
-        response = client.chat.with_raw_response.completions()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        chat = response.parse()
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    def test_streaming_response_completions(self, client: Arcade) -> None:
-        with client.chat.with_streaming_response.completions() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            chat = response.parse()
-            assert_matches_type(ChatResponse, chat, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncChat:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    async def test_method_completions(self, async_client: AsyncArcade) -> None:
-        chat = await async_client.chat.completions()
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    async def test_method_completions_with_all_params(self, async_client: AsyncArcade) -> None:
-        chat = await async_client.chat.completions(
-            frequency_penalty=0,
-            logit_bias={"foo": 0},
-            logprobs=True,
-            max_tokens=0,
-            messages=[
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-            ],
-            model="model",
-            n=0,
-            parallel_tool_calls=True,
-            presence_penalty=0,
-            response_format="json_object",
-            seed=0,
-            stop=["string", "string", "string"],
-            stream=True,
-            stream_options={"include_usage": True},
-            temperature=0,
-            tool_choice="",
-            tools={},
-            top_logprobs=0,
-            top_p=0,
-            user="user",
-        )
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    async def test_raw_response_completions(self, async_client: AsyncArcade) -> None:
-        response = await async_client.chat.with_raw_response.completions()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        chat = await response.parse()
-        assert_matches_type(ChatResponse, chat, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_completions(self, async_client: AsyncArcade) -> None:
-        async with async_client.chat.with_streaming_response.completions() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            chat = await response.parse()
-            assert_matches_type(ChatResponse, chat, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_llm_completions.py b/tests/api_resources/test_llm_completions.py
deleted file mode 100644
index b2e7127..0000000
--- a/tests/api_resources/test_llm_completions.py
+++ /dev/null
@@ -1,318 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, cast
-
-import pytest
-
-from tests.utils import assert_matches_type
-from arcade_engine import ArcadeEngine, AsyncArcadeEngine
-from arcade_engine.types import ChatResponse
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestLlmCompletions:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    def test_method_create(self, client: ArcadeEngine) -> None:
-        llm_completion = client.llm_completions.create()
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    def test_method_create_with_all_params(self, client: ArcadeEngine) -> None:
-        llm_completion = client.llm_completions.create(
-            frequency_penalty=0,
-            logit_bias={"foo": 0},
-            logprobs=True,
-            max_tokens=0,
-            messages=[
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-            ],
-            model="model",
-            n=0,
-            parallel_tool_calls={},
-            presence_penalty=0,
-            response_format="json_object",
-            seed=0,
-            stop=["string", "string", "string"],
-            stream=True,
-            stream_options={"include_usage": True},
-            temperature=0,
-            tool_choice="",
-            tools={},
-            top_logprobs=0,
-            top_p=0,
-            user="user",
-        )
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    def test_raw_response_create(self, client: ArcadeEngine) -> None:
-        response = client.llm_completions.with_raw_response.create()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        llm_completion = response.parse()
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    def test_streaming_response_create(self, client: ArcadeEngine) -> None:
-        with client.llm_completions.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            llm_completion = response.parse()
-            assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncLlmCompletions:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    async def test_method_create(self, async_client: AsyncArcadeEngine) -> None:
-        llm_completion = await async_client.llm_completions.create()
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    async def test_method_create_with_all_params(self, async_client: AsyncArcadeEngine) -> None:
-        llm_completion = await async_client.llm_completions.create(
-            frequency_penalty=0,
-            logit_bias={"foo": 0},
-            logprobs=True,
-            max_tokens=0,
-            messages=[
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-                {
-                    "content": "content",
-                    "role": "role",
-                    "name": "name",
-                    "tool_call_id": "tool_call_id",
-                    "tool_calls": [
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                        {
-                            "id": "id",
-                            "function": {
-                                "arguments": "arguments",
-                                "name": "name",
-                            },
-                            "type": "function",
-                        },
-                    ],
-                },
-            ],
-            model="model",
-            n=0,
-            parallel_tool_calls={},
-            presence_penalty=0,
-            response_format="json_object",
-            seed=0,
-            stop=["string", "string", "string"],
-            stream=True,
-            stream_options={"include_usage": True},
-            temperature=0,
-            tool_choice="",
-            tools={},
-            top_logprobs=0,
-            top_p=0,
-            user="user",
-        )
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    async def test_raw_response_create(self, async_client: AsyncArcadeEngine) -> None:
-        response = await async_client.llm_completions.with_raw_response.create()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        llm_completion = await response.parse()
-        assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_create(self, async_client: AsyncArcadeEngine) -> None:
-        async with async_client.llm_completions.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            llm_completion = await response.parse()
-            assert_matches_type(ChatResponse, llm_completion, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_operations.py b/tests/api_resources/test_operations.py
deleted file mode 100644
index 79d8208..0000000
--- a/tests/api_resources/test_operations.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, cast
-
-import pytest
-
-from tests.utils import assert_matches_type
-from arcade_engine import ArcadeEngine, AsyncArcadeEngine
-from arcade_engine.types import HealthSchema
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestOperations:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    def test_method_health(self, client: ArcadeEngine) -> None:
-        operation = client.operations.health()
-        assert_matches_type(HealthSchema, operation, path=["response"])
-
-    @parametrize
-    def test_raw_response_health(self, client: ArcadeEngine) -> None:
-        response = client.operations.with_raw_response.health()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        operation = response.parse()
-        assert_matches_type(HealthSchema, operation, path=["response"])
-
-    @parametrize
-    def test_streaming_response_health(self, client: ArcadeEngine) -> None:
-        with client.operations.with_streaming_response.health() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            operation = response.parse()
-            assert_matches_type(HealthSchema, operation, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncOperations:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    async def test_method_health(self, async_client: AsyncArcadeEngine) -> None:
-        operation = await async_client.operations.health()
-        assert_matches_type(HealthSchema, operation, path=["response"])
-
-    @parametrize
-    async def test_raw_response_health(self, async_client: AsyncArcadeEngine) -> None:
-        response = await async_client.operations.with_raw_response.health()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        operation = await response.parse()
-        assert_matches_type(HealthSchema, operation, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_health(self, async_client: AsyncArcadeEngine) -> None:
-        async with async_client.operations.with_streaming_response.health() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            operation = await response.parse()
-            assert_matches_type(HealthSchema, operation, path=["response"])
-
-        assert cast(Any, response.is_closed) is True