chore(internal): codegen related update

Author: stainless-app[bot]

src/parallel/_client.py

@@ -104,6 +104,11 @@ def __init__(
 
     @cached_property
     def task_run(self) -> TaskRunResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import TaskRunResource
 
         return TaskRunResource(self)
@@ -284,6 +289,11 @@ def __init__(
 
     @cached_property
     def task_run(self) -> AsyncTaskRunResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import AsyncTaskRunResource
 
         return AsyncTaskRunResource(self)
@@ -415,6 +425,11 @@ def __init__(self, client: Parallel) -> None:
 
     @cached_property
     def task_run(self) -> task_run.TaskRunResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import TaskRunResourceWithRawResponse
 
         return TaskRunResourceWithRawResponse(self._client.task_run)
@@ -434,6 +449,11 @@ def __init__(self, client: AsyncParallel) -> None:
 
     @cached_property
     def task_run(self) -> task_run.AsyncTaskRunResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import AsyncTaskRunResourceWithRawResponse
 
         return AsyncTaskRunResourceWithRawResponse(self._client.task_run)
@@ -453,6 +473,11 @@ def __init__(self, client: Parallel) -> None:
 
     @cached_property
     def task_run(self) -> task_run.TaskRunResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import TaskRunResourceWithStreamingResponse
 
         return TaskRunResourceWithStreamingResponse(self._client.task_run)
@@ -472,6 +497,11 @@ def __init__(self, client: AsyncParallel) -> None:
 
     @cached_property
     def task_run(self) -> task_run.AsyncTaskRunResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         from .resources.task_run import AsyncTaskRunResourceWithStreamingResponse
 
         return AsyncTaskRunResourceWithStreamingResponse(self._client.task_run)

src/parallel/resources/beta/beta.py

@@ -57,14 +57,31 @@
 class BetaResource(SyncAPIResource):
     @cached_property
     def task_run(self) -> TaskRunResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return TaskRunResource(self._client)
 
     @cached_property
     def task_group(self) -> TaskGroupResource:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return TaskGroupResource(self._client)
 
     @cached_property
     def findall(self) -> FindAllResource:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return FindAllResource(self._client)
 
     @cached_property
@@ -265,14 +282,31 @@ def search(
 class AsyncBetaResource(AsyncAPIResource):
     @cached_property
     def task_run(self) -> AsyncTaskRunResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return AsyncTaskRunResource(self._client)
 
     @cached_property
     def task_group(self) -> AsyncTaskGroupResource:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return AsyncTaskGroupResource(self._client)
 
     @cached_property
     def findall(self) -> AsyncFindAllResource:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return AsyncFindAllResource(self._client)
 
     @cached_property
@@ -483,14 +517,31 @@ def __init__(self, beta: BetaResource) -> None:
 
     @cached_property
     def task_run(self) -> TaskRunResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return TaskRunResourceWithRawResponse(self._beta.task_run)
 
     @cached_property
     def task_group(self) -> TaskGroupResourceWithRawResponse:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return TaskGroupResourceWithRawResponse(self._beta.task_group)
 
     @cached_property
     def findall(self) -> FindAllResourceWithRawResponse:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return FindAllResourceWithRawResponse(self._beta.findall)
 
 
@@ -507,14 +558,31 @@ def __init__(self, beta: AsyncBetaResource) -> None:
 
     @cached_property
     def task_run(self) -> AsyncTaskRunResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return AsyncTaskRunResourceWithRawResponse(self._beta.task_run)
 
     @cached_property
     def task_group(self) -> AsyncTaskGroupResourceWithRawResponse:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return AsyncTaskGroupResourceWithRawResponse(self._beta.task_group)
 
     @cached_property
     def findall(self) -> AsyncFindAllResourceWithRawResponse:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return AsyncFindAllResourceWithRawResponse(self._beta.findall)
 
 
@@ -531,14 +599,31 @@ def __init__(self, beta: BetaResource) -> None:
 
     @cached_property
     def task_run(self) -> TaskRunResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return TaskRunResourceWithStreamingResponse(self._beta.task_run)
 
     @cached_property
     def task_group(self) -> TaskGroupResourceWithStreamingResponse:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return TaskGroupResourceWithStreamingResponse(self._beta.task_group)
 
     @cached_property
     def findall(self) -> FindAllResourceWithStreamingResponse:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return FindAllResourceWithStreamingResponse(self._beta.findall)
 
 
@@ -555,12 +640,29 @@ def __init__(self, beta: AsyncBetaResource) -> None:
 
     @cached_property
     def task_run(self) -> AsyncTaskRunResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+        """
         return AsyncTaskRunResourceWithStreamingResponse(self._beta.task_run)
 
     @cached_property
     def task_group(self) -> AsyncTaskGroupResourceWithStreamingResponse:
+        """
+        The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+         - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        Status: beta and subject to change.
+        """
         return AsyncTaskGroupResourceWithStreamingResponse(self._beta.task_group)
 
     @cached_property
     def findall(self) -> AsyncFindAllResourceWithStreamingResponse:
+        """
+        The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+        """
         return AsyncFindAllResourceWithStreamingResponse(self._beta.findall)

src/parallel/resources/beta/findall.py

@@ -53,6 +53,10 @@
 
 
 class FindAllResource(SyncAPIResource):
+    """
+    The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+    """
+
     @cached_property
     def with_raw_response(self) -> FindAllResourceWithRawResponse:
         """
@@ -594,6 +598,10 @@ def schema(
 
 
 class AsyncFindAllResource(AsyncAPIResource):
+    """
+    The FindAll API discovers and evaluates entities that match complex criteria from natural language objectives. Submit a high-level goal and the service automatically generates structured match conditions, discovers relevant candidates, and evaluates each against the criteria. Returns comprehensive results with detailed reasoning, citations, and confidence scores for each match decision. Streaming events and webhooks are supported.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncFindAllResourceWithRawResponse:
         """

src/parallel/resources/beta/task_group.py

@@ -38,6 +38,16 @@
 
 
 class TaskGroupResource(SyncAPIResource):
+    """
+    The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+     - Submit hundreds or thousands of Tasks as a single group
+    - Observe group progress and receive results as they complete
+    - Real-time updates via Server-Sent Events (SSE)
+    - Add tasks to an existing group while it is running
+    - Group-level retry and error aggregation
+    Status: beta and subject to change.
+    """
+
     @cached_property
     def with_raw_response(self) -> TaskGroupResourceWithRawResponse:
         """
@@ -314,6 +324,16 @@ def get_runs(
 
 
 class AsyncTaskGroupResource(AsyncAPIResource):
+    """
+    The Task Group API is currently in beta and enables batch execution of many independent Task runs with group-level monitoring and failure handling.
+     - Submit hundreds or thousands of Tasks as a single group
+    - Observe group progress and receive results as they complete
+    - Real-time updates via Server-Sent Events (SSE)
+    - Add tasks to an existing group while it is running
+    - Group-level retry and error aggregation
+    Status: beta and subject to change.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncTaskGroupResourceWithRawResponse:
         """