feat(api): add ai detect tool endpoint

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 31
+configured_endpoints: 32
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/writerai%2Fwriter-a0e83ebfd81856b538d16c7a41ccdc11687ee558e1435a40f3bb7e0d6e1ab7c8.yml
 openapi_spec_hash: 8ac62303a9158c13f344975cb0786bc6
-config_hash: 1f6d0bf7309d0007e28ab85b89a0de85
+config_hash: b1d3b26784527ee46af49c1bb9e93193

api.md

@@ -162,11 +162,16 @@ Methods:
 Types:
 
 ```python
-from writerai.types import ToolContextAwareSplittingResponse, ToolParsePdfResponse
+from writerai.types import (
+    ToolAIDetectResponse,
+    ToolContextAwareSplittingResponse,
+    ToolParsePdfResponse,
+)
 ```
 
 Methods:
 
+- <code title="post /v1/tools/ai-detect">client.tools.<a href="./src/writerai/resources/tools/tools.py">ai_detect</a>(\*\*<a href="src/writerai/types/tool_ai_detect_params.py">params</a>) -> <a href="./src/writerai/types/tool_ai_detect_response.py">ToolAIDetectResponse</a></code>
 - <code title="post /v1/tools/context-aware-splitting">client.tools.<a href="./src/writerai/resources/tools/tools.py">context_aware_splitting</a>(\*\*<a href="src/writerai/types/tool_context_aware_splitting_params.py">params</a>) -> <a href="./src/writerai/types/tool_context_aware_splitting_response.py">ToolContextAwareSplittingResponse</a></code>
 - <code title="post /v1/tools/pdf-parser/{file_id}">client.tools.<a href="./src/writerai/resources/tools/tools.py">parse_pdf</a>(file_id, \*\*<a href="src/writerai/types/tool_parse_pdf_params.py">params</a>) -> <a href="./src/writerai/types/tool_parse_pdf_response.py">ToolParsePdfResponse</a></code>
 

src/writerai/resources/tools/tools.py

@@ -6,7 +6,7 @@
 
 import httpx
 
-from ...types import tool_parse_pdf_params, tool_context_aware_splitting_params
+from ...types import tool_ai_detect_params, tool_parse_pdf_params, tool_context_aware_splitting_params
 from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
@@ -26,6 +26,7 @@
     async_to_streamed_response_wrapper,
 )
 from ..._base_client import make_request_options
+from ...types.tool_ai_detect_response import ToolAIDetectResponse
 from ...types.tool_parse_pdf_response import ToolParsePdfResponse
 from ...types.tool_context_aware_splitting_response import ToolContextAwareSplittingResponse
 
@@ -56,6 +57,43 @@ def with_streaming_response(self) -> ToolsResourceWithStreamingResponse:
         """
         return ToolsResourceWithStreamingResponse(self)
 
+    def ai_detect(
+        self,
+        *,
+        input: str,
+        # 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,
+    ) -> ToolAIDetectResponse:
+        """Detects if content is AI- or human-generated, with a confidence score.
+
+        Content
+        must have at least 350 characters
+
+        Args:
+          input: The content to determine if it is AI- or human-generated. Content must have at
+              least 350 characters.
+
+          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/tools/ai-detect",
+            body=maybe_transform({"input": input}, tool_ai_detect_params.ToolAIDetectParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ToolAIDetectResponse,
+        )
+
     def context_aware_splitting(
         self,
         *,
@@ -164,6 +202,43 @@ def with_streaming_response(self) -> AsyncToolsResourceWithStreamingResponse:
         """
         return AsyncToolsResourceWithStreamingResponse(self)
 
+    async def ai_detect(
+        self,
+        *,
+        input: str,
+        # 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,
+    ) -> ToolAIDetectResponse:
+        """Detects if content is AI- or human-generated, with a confidence score.
+
+        Content
+        must have at least 350 characters
+
+        Args:
+          input: The content to determine if it is AI- or human-generated. Content must have at
+              least 350 characters.
+
+          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/tools/ai-detect",
+            body=await async_maybe_transform({"input": input}, tool_ai_detect_params.ToolAIDetectParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ToolAIDetectResponse,
+        )
+
     async def context_aware_splitting(
         self,
         *,
@@ -252,6 +327,9 @@ class ToolsResourceWithRawResponse:
     def __init__(self, tools: ToolsResource) -> None:
         self._tools = tools
 
+        self.ai_detect = to_raw_response_wrapper(
+            tools.ai_detect,
+        )
         self.context_aware_splitting = to_raw_response_wrapper(
             tools.context_aware_splitting,
         )
@@ -268,6 +346,9 @@ class AsyncToolsResourceWithRawResponse:
     def __init__(self, tools: AsyncToolsResource) -> None:
         self._tools = tools
 
+        self.ai_detect = async_to_raw_response_wrapper(
+            tools.ai_detect,
+        )
         self.context_aware_splitting = async_to_raw_response_wrapper(
             tools.context_aware_splitting,
         )
@@ -284,6 +365,9 @@ class ToolsResourceWithStreamingResponse:
     def __init__(self, tools: ToolsResource) -> None:
         self._tools = tools
 
+        self.ai_detect = to_streamed_response_wrapper(
+            tools.ai_detect,
+        )
         self.context_aware_splitting = to_streamed_response_wrapper(
             tools.context_aware_splitting,
         )
@@ -300,6 +384,9 @@ class AsyncToolsResourceWithStreamingResponse:
     def __init__(self, tools: AsyncToolsResource) -> None:
         self._tools = tools
 
+        self.ai_detect = async_to_streamed_response_wrapper(
+            tools.ai_detect,
+        )
         self.context_aware_splitting = async_to_streamed_response_wrapper(
             tools.context_aware_splitting,
         )

src/writerai/types/__init__.py

@@ -41,12 +41,14 @@
 from .graph_delete_response import GraphDeleteResponse as GraphDeleteResponse
 from .graph_question_params import GraphQuestionParams as GraphQuestionParams
 from .graph_update_response import GraphUpdateResponse as GraphUpdateResponse
+from .tool_ai_detect_params import ToolAIDetectParams as ToolAIDetectParams
 from .tool_parse_pdf_params import ToolParsePdfParams as ToolParsePdfParams
 from .vision_analyze_params import VisionAnalyzeParams as VisionAnalyzeParams
 from .chat_completion_choice import ChatCompletionChoice as ChatCompletionChoice
 from .application_list_params import ApplicationListParams as ApplicationListParams
 from .chat_completion_message import ChatCompletionMessage as ChatCompletionMessage
 from .question_response_chunk import QuestionResponseChunk as QuestionResponseChunk
+from .tool_ai_detect_response import ToolAIDetectResponse as ToolAIDetectResponse
 from .tool_parse_pdf_response import ToolParsePdfResponse as ToolParsePdfResponse
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
 from .application_list_response import ApplicationListResponse as ApplicationListResponse

src/writerai/types/tool_ai_detect_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ToolAIDetectParams"]
+
+
+class ToolAIDetectParams(TypedDict, total=False):
+    input: Required[str]
+    """The content to determine if it is AI- or human-generated.
+
+    Content must have at least 350 characters.
+    """

src/writerai/types/tool_ai_detect_response.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ToolAIDetectResponse"]
+
+
+class ToolAIDetectResponse(BaseModel):
+    label: Literal["fake", "real"]
+
+    score: float

tests/api_resources/test_tools.py

@@ -10,6 +10,7 @@
 from writerai import Writer, AsyncWriter
 from tests.utils import assert_matches_type
 from writerai.types import (
+    ToolAIDetectResponse,
     ToolParsePdfResponse,
     ToolContextAwareSplittingResponse,
 )
@@ -20,6 +21,37 @@
 class TestTools:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
+    @parametrize
+    def test_method_ai_detect(self, client: Writer) -> None:
+        tool = client.tools.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        )
+        assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+    @parametrize
+    def test_raw_response_ai_detect(self, client: Writer) -> None:
+        response = client.tools.with_raw_response.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        tool = response.parse()
+        assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+    @parametrize
+    def test_streaming_response_ai_detect(self, client: Writer) -> None:
+        with client.tools.with_streaming_response.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            tool = response.parse()
+            assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
     @parametrize
     def test_method_context_aware_splitting(self, client: Writer) -> None:
         tool = client.tools.context_aware_splitting(
@@ -100,6 +132,37 @@ def test_path_params_parse_pdf(self, client: Writer) -> None:
 class TestAsyncTools:
     parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
 
+    @parametrize
+    async def test_method_ai_detect(self, async_client: AsyncWriter) -> None:
+        tool = await async_client.tools.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        )
+        assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+    @parametrize
+    async def test_raw_response_ai_detect(self, async_client: AsyncWriter) -> None:
+        response = await async_client.tools.with_raw_response.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        tool = await response.parse()
+        assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_ai_detect(self, async_client: AsyncWriter) -> None:
+        async with async_client.tools.with_streaming_response.ai_detect(
+            input="AI and ML continue to be at the forefront of technological advancements. In 2025, we can expect more sophisticated AI systems that can handle complex tasks with greater efficiency. AI will play a crucial role in various sectors, including healthcare, finance, and manufacturing. For instance, AI-powered diagnostic tools will become more accurate, helping doctors detect diseases at an early stage. In finance, AI algorithms will enhance fraud detection and risk management.",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            tool = await response.parse()
+            assert_matches_type(ToolAIDetectResponse, tool, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
     @parametrize
     async def test_method_context_aware_splitting(self, async_client: AsyncWriter) -> None:
         tool = await async_client.tools.context_aware_splitting(