raccoonai 0.1.0a6__py3-none-any.whl → 0.1.0a8__py3-none-any.whl

raccoonai/resources/lam.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional, cast
+from typing import List, Iterable, Optional
 from typing_extensions import Literal, overload
 
 import httpx
 
-from ..types import lam_run_params, lam_extract_params, lam_integration_run_params
+from ..types import lam_run_params, lam_tasks_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from .._utils import (
     required_args,
@@ -25,8 +25,7 @@ from .._response import (
 from .._streaming import Stream, AsyncStream
 from .._base_client import make_request_options
 from ..types.lam_run_response import LamRunResponse
-from ..types.lam_extract_response import LamExtractResponse
-from ..types.lam_integration_run_response import LamIntegrationRunResponse
+from ..types.lam_tasks_response import LamTasksResponse
 
 __all__ = ["LamResource", "AsyncLamResource"]
 
@@ -52,592 +51,16 @@ class LamResource(SyncAPIResource):
         return LamResourceWithStreamingResponse(self)
 
     @overload
-    def extract(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        max_count: Optional[int] | NotGiven = NOT_GIVEN,
-        schema: object | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse:
-        """Lam Extract Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          max_count: The maximum number of results to extract.
-
-          schema: The expected schema for the response. This is a dictionary where the keys
-              describe the fields and the values describe their purposes.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    def extract(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        max_count: Optional[int] | NotGiven = NOT_GIVEN,
-        schema: object | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Stream[LamExtractResponse]:
-        """Lam Extract Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          max_count: The maximum number of results to extract.
-
-          schema: The expected schema for the response. This is a dictionary where the keys
-              describe the fields and the values describe their purposes.
-
-          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
-        """
-        ...
-
-    @overload
-    def extract(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        max_count: Optional[int] | NotGiven = NOT_GIVEN,
-        schema: object | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse | Stream[LamExtractResponse]:
-        """Lam Extract Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          max_count: The maximum number of results to extract.
-
-          schema: The expected schema for the response. This is a dictionary where the keys
-              describe the fields and the values describe their purposes.
-
-          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
-        """
-        ...
-
-    @required_args(["query", "raccoon_passcode"], ["query", "raccoon_passcode", "stream"])
-    def extract(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        max_count: Optional[int] | NotGiven = NOT_GIVEN,
-        schema: object | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse | Stream[LamExtractResponse]:
-        return self._post(
-            "/lam/extract",
-            body=maybe_transform(
-                {
-                    "query": query,
-                    "raccoon_passcode": raccoon_passcode,
-                    "advanced": advanced,
-                    "app_url": app_url,
-                    "chat_history": chat_history,
-                    "max_count": max_count,
-                    "schema": schema,
-                    "stream": stream,
-                },
-                lam_extract_params.LamExtractParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=LamExtractResponse,
-            stream=stream or False,
-            stream_cls=Stream[LamExtractResponse],
-        )
-
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Stream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          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
-        """
-        ...
-
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse | Stream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          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
-        """
-        ...
-
-    @required_args(["raccoon_passcode"], ["raccoon_passcode", "stream"])
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse | Stream[LamIntegrationRunResponse]:
-        if not app_name:
-            raise ValueError(f"Expected a non-empty value for `app_name` but received {app_name!r}")
-        return cast(
-            LamIntegrationRunResponse,
-            self._post(
-                f"/lam/{app_name}/run",
-                body=maybe_transform(
-                    {
-                        "raccoon_passcode": raccoon_passcode,
-                        "advanced": advanced,
-                        "integration_id": integration_id,
-                        "properties": properties,
-                        "stream": stream,
-                    },
-                    lam_integration_run_params.LamIntegrationRunParams,
-                ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-                ),
-                cast_to=cast(
-                    Any, LamIntegrationRunResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=Stream[LamIntegrationRunResponse],
-            ),
-        )
-
-    @overload
-    def run(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamRunResponse:
-        """Lam Run Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    def run(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Stream[LamRunResponse]:
-        """Lam Run Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          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
-        """
-        ...
-
-    @overload
-    def run(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamRunResponse | Stream[LamRunResponse]:
-        """Lam Run Endpoint
-
-        Args:
-          query: The input query string for the request.
-
-        This is typically the main prompt.
-
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          app_url: This is the entrypoint URL for the web agent.
-
-          chat_history: The history of the conversation as a list of messages or objects you might use
-              while building a chat app to give the model context of the past conversation.
-
-          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
-        """
-        ...
-
-    @required_args(["query", "raccoon_passcode"], ["query", "raccoon_passcode", "stream"])
-    def run(
-        self,
-        *,
-        query: str,
-        raccoon_passcode: str,
-        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        app_url: Optional[str] | NotGiven = NOT_GIVEN,
-        chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamRunResponse | Stream[LamRunResponse]:
-        return self._post(
-            "/lam/run",
-            body=maybe_transform(
-                {
-                    "query": query,
-                    "raccoon_passcode": raccoon_passcode,
-                    "advanced": advanced,
-                    "app_url": app_url,
-                    "chat_history": chat_history,
-                    "stream": stream,
-                },
-                lam_run_params.LamRunParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=LamRunResponse,
-            stream=stream or False,
-            stream_cls=Stream[LamRunResponse],
-        )
-
-
-class AsyncLamResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncLamResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncLamResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncLamResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
-        """
-        return AsyncLamResourceWithStreamingResponse(self)
-
-    @overload
-    async def extract(
+    def run(
         self,
         *,
         query: str,
         raccoon_passcode: str,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
         max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
         schema: object | NotGiven = NOT_GIVEN,
         stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -646,8 +69,8 @@ class AsyncLamResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse:
-        """Lam Extract Endpoint
+    ) -> LamRunResponse:
+        """Lam Run Endpoint
 
         Args:
           query: The input query string for the request.
@@ -667,6 +90,8 @@ class AsyncLamResource(AsyncAPIResource):
 
           max_count: The maximum number of results to extract.
 
+          mode: Mode of execution.
+
           schema: The expected schema for the response. This is a dictionary where the keys
               describe the fields and the values describe their purposes.
 
@@ -683,16 +108,17 @@ class AsyncLamResource(AsyncAPIResource):
         ...
 
     @overload
-    async def extract(
+    def run(
         self,
         *,
         query: str,
         raccoon_passcode: str,
         stream: Literal[True],
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
         max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
         schema: object | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -700,8 +126,8 @@ class AsyncLamResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> AsyncStream[LamExtractResponse]:
-        """Lam Extract Endpoint
+    ) -> Stream[LamRunResponse]:
+        """Lam Run Endpoint
 
         Args:
           query: The input query string for the request.
@@ -723,6 +149,8 @@ class AsyncLamResource(AsyncAPIResource):
 
           max_count: The maximum number of results to extract.
 
+          mode: Mode of execution.
+
           schema: The expected schema for the response. This is a dictionary where the keys
               describe the fields and the values describe their purposes.
 
@@ -737,16 +165,17 @@ class AsyncLamResource(AsyncAPIResource):
         ...
 
     @overload
-    async def extract(
+    def run(
         self,
         *,
         query: str,
         raccoon_passcode: str,
         stream: bool,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
         max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
         schema: object | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -754,8 +183,8 @@ class AsyncLamResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse | AsyncStream[LamExtractResponse]:
-        """Lam Extract Endpoint
+    ) -> LamRunResponse | Stream[LamRunResponse]:
+        """Lam Run Endpoint
 
         Args:
           query: The input query string for the request.
@@ -777,6 +206,8 @@ class AsyncLamResource(AsyncAPIResource):
 
           max_count: The maximum number of results to extract.
 
+          mode: Mode of execution.
+
           schema: The expected schema for the response. This is a dictionary where the keys
               describe the fields and the values describe their purposes.
 
@@ -791,15 +222,16 @@ class AsyncLamResource(AsyncAPIResource):
         ...
 
     @required_args(["query", "raccoon_passcode"], ["query", "raccoon_passcode", "stream"])
-    async def extract(
+    def run(
         self,
         *,
         query: str,
         raccoon_passcode: str,
-        advanced: Optional[lam_extract_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
         max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
         schema: object | NotGiven = NOT_GIVEN,
         stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -808,10 +240,10 @@ class AsyncLamResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamExtractResponse | AsyncStream[LamExtractResponse]:
-        return await self._post(
-            "/lam/extract",
-            body=await async_maybe_transform(
+    ) -> LamRunResponse | Stream[LamRunResponse]:
+        return self._post(
+            "/lam/run",
+            body=maybe_transform(
                 {
                     "query": query,
                     "raccoon_passcode": raccoon_passcode,
@@ -819,137 +251,61 @@ class AsyncLamResource(AsyncAPIResource):
                     "app_url": app_url,
                     "chat_history": chat_history,
                     "max_count": max_count,
+                    "mode": mode,
                     "schema": schema,
                     "stream": stream,
                 },
-                lam_extract_params.LamExtractParams,
+                lam_run_params.LamRunParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=LamExtractResponse,
+            cast_to=LamRunResponse,
             stream=stream or False,
-            stream_cls=AsyncStream[LamExtractResponse],
+            stream_cls=Stream[LamRunResponse],
         )
 
-    @overload
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    async def integration_run(
+    def tasks(
         self,
-        app_name: str,
         *,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
+        end_time: Optional[int] | NotGiven = NOT_GIVEN,
+        execution_type: Optional[List[Literal["run", "extract", "fleet"]]] | NotGiven = NOT_GIVEN,
+        limit: Optional[int] | NotGiven = NOT_GIVEN,
+        page: Optional[int] | NotGiven = NOT_GIVEN,
+        raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
+        sort_by: Optional[Literal["timestamp", "executionTime", "taskId", "status", "executionType"]]
+        | NotGiven = NOT_GIVEN,
+        sort_order: Optional[Literal["ascend", "descend"]] | NotGiven = NOT_GIVEN,
+        start_time: Optional[int] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> AsyncStream[LamIntegrationRunResponse]:
+    ) -> LamTasksResponse:
         """
-        Lam Integrations Endpoint
+        Get Tasks Endpoint
 
         Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
+          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
 
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          extra_headers: Send extra headers
+          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
 
-          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
-        """
-        ...
+          limit: Number of tasks per page (maximum 100).
 
-    @overload
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse | AsyncStream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
+          page: Page number for pagination.
 
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
+          raccoon_passcode: Filter tasks by Raccoon passcode.
 
-          stream: Whether the response should be streamed back or not.
+          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
 
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
+          sort_order: Sort order ('ascend' or 'descend').
 
-          integration_id: The unique identifier for the integration being called.
+          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
 
-          properties: Additional properties or data related to the particular integration.
+          task_id: Filter tasks by a specific task ID.
 
           extra_headers: Send extra headers
 
@@ -959,52 +315,52 @@ class AsyncLamResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        ...
-
-    @required_args(["raccoon_passcode"], ["raccoon_passcode", "stream"])
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> LamIntegrationRunResponse | AsyncStream[LamIntegrationRunResponse]:
-        if not app_name:
-            raise ValueError(f"Expected a non-empty value for `app_name` but received {app_name!r}")
-        return cast(
-            LamIntegrationRunResponse,
-            await self._post(
-                f"/lam/{app_name}/run",
-                body=await async_maybe_transform(
+        return self._get(
+            "/lam/tasks",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
                     {
+                        "end_time": end_time,
+                        "execution_type": execution_type,
+                        "limit": limit,
+                        "page": page,
                         "raccoon_passcode": raccoon_passcode,
-                        "advanced": advanced,
-                        "integration_id": integration_id,
-                        "properties": properties,
-                        "stream": stream,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
                     },
-                    lam_integration_run_params.LamIntegrationRunParams,
+                    lam_tasks_params.LamTasksParams,
                 ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-                ),
-                cast_to=cast(
-                    Any, LamIntegrationRunResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=AsyncStream[LamIntegrationRunResponse],
             ),
+            cast_to=LamTasksResponse,
         )
 
+
+class AsyncLamResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncLamResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncLamResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncLamResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
+        """
+        return AsyncLamResourceWithStreamingResponse(self)
+
     @overload
     async def run(
         self,
@@ -1014,6 +370,9 @@ class AsyncLamResource(AsyncAPIResource):
         advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
+        max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
+        schema: object | NotGiven = NOT_GIVEN,
         stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1040,6 +399,13 @@ class AsyncLamResource(AsyncAPIResource):
           chat_history: The history of the conversation as a list of messages or objects you might use
               while building a chat app to give the model context of the past conversation.
 
+          max_count: The maximum number of results to extract.
+
+          mode: Mode of execution.
+
+          schema: The expected schema for the response. This is a dictionary where the keys
+              describe the fields and the values describe their purposes.
+
           stream: Whether the response should be streamed back or not.
 
           extra_headers: Send extra headers
@@ -1062,6 +428,9 @@ class AsyncLamResource(AsyncAPIResource):
         advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
+        max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
+        schema: object | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1089,6 +458,13 @@ class AsyncLamResource(AsyncAPIResource):
           chat_history: The history of the conversation as a list of messages or objects you might use
               while building a chat app to give the model context of the past conversation.
 
+          max_count: The maximum number of results to extract.
+
+          mode: Mode of execution.
+
+          schema: The expected schema for the response. This is a dictionary where the keys
+              describe the fields and the values describe their purposes.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -1109,6 +485,9 @@ class AsyncLamResource(AsyncAPIResource):
         advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
+        max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
+        schema: object | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1136,6 +515,13 @@ class AsyncLamResource(AsyncAPIResource):
           chat_history: The history of the conversation as a list of messages or objects you might use
               while building a chat app to give the model context of the past conversation.
 
+          max_count: The maximum number of results to extract.
+
+          mode: Mode of execution.
+
+          schema: The expected schema for the response. This is a dictionary where the keys
+              describe the fields and the values describe their purposes.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -1155,6 +541,9 @@ class AsyncLamResource(AsyncAPIResource):
         advanced: Optional[lam_run_params.Advanced] | NotGiven = NOT_GIVEN,
         app_url: Optional[str] | NotGiven = NOT_GIVEN,
         chat_history: Optional[Iterable[object]] | NotGiven = NOT_GIVEN,
+        max_count: Optional[int] | NotGiven = NOT_GIVEN,
+        mode: Optional[Literal["deepsearch", "default"]] | NotGiven = NOT_GIVEN,
+        schema: object | NotGiven = NOT_GIVEN,
         stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1172,6 +561,9 @@ class AsyncLamResource(AsyncAPIResource):
                     "advanced": advanced,
                     "app_url": app_url,
                     "chat_history": chat_history,
+                    "max_count": max_count,
+                    "mode": mode,
+                    "schema": schema,
                     "stream": stream,
                 },
                 lam_run_params.LamRunParams,
@@ -1184,62 +576,125 @@ class AsyncLamResource(AsyncAPIResource):
             stream_cls=AsyncStream[LamRunResponse],
         )
 
+    async def tasks(
+        self,
+        *,
+        end_time: Optional[int] | NotGiven = NOT_GIVEN,
+        execution_type: Optional[List[Literal["run", "extract", "fleet"]]] | NotGiven = NOT_GIVEN,
+        limit: Optional[int] | NotGiven = NOT_GIVEN,
+        page: Optional[int] | NotGiven = NOT_GIVEN,
+        raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
+        sort_by: Optional[Literal["timestamp", "executionTime", "taskId", "status", "executionType"]]
+        | NotGiven = NOT_GIVEN,
+        sort_order: Optional[Literal["ascend", "descend"]] | NotGiven = NOT_GIVEN,
+        start_time: Optional[int] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> LamTasksResponse:
+        """
+        Get Tasks Endpoint
+
+        Args:
+          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
+
+          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
+
+          limit: Number of tasks per page (maximum 100).
+
+          page: Page number for pagination.
+
+          raccoon_passcode: Filter tasks by Raccoon passcode.
+
+          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
+
+          sort_order: Sort order ('ascend' or 'descend').
+
+          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
+
+          task_id: Filter tasks by a specific task ID.
+
+          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._get(
+            "/lam/tasks",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "end_time": end_time,
+                        "execution_type": execution_type,
+                        "limit": limit,
+                        "page": page,
+                        "raccoon_passcode": raccoon_passcode,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
+                    },
+                    lam_tasks_params.LamTasksParams,
+                ),
+            ),
+            cast_to=LamTasksResponse,
+        )
+
 
 class LamResourceWithRawResponse:
     def __init__(self, lam: LamResource) -> None:
         self._lam = lam
 
-        self.extract = to_raw_response_wrapper(
-            lam.extract,
-        )
-        self.integration_run = to_raw_response_wrapper(
-            lam.integration_run,
-        )
         self.run = to_raw_response_wrapper(
             lam.run,
         )
+        self.tasks = to_raw_response_wrapper(
+            lam.tasks,
+        )
 
 
 class AsyncLamResourceWithRawResponse:
     def __init__(self, lam: AsyncLamResource) -> None:
         self._lam = lam
 
-        self.extract = async_to_raw_response_wrapper(
-            lam.extract,
-        )
-        self.integration_run = async_to_raw_response_wrapper(
-            lam.integration_run,
-        )
         self.run = async_to_raw_response_wrapper(
             lam.run,
         )
+        self.tasks = async_to_raw_response_wrapper(
+            lam.tasks,
+        )
 
 
 class LamResourceWithStreamingResponse:
     def __init__(self, lam: LamResource) -> None:
         self._lam = lam
 
-        self.extract = to_streamed_response_wrapper(
-            lam.extract,
-        )
-        self.integration_run = to_streamed_response_wrapper(
-            lam.integration_run,
-        )
         self.run = to_streamed_response_wrapper(
             lam.run,
         )
+        self.tasks = to_streamed_response_wrapper(
+            lam.tasks,
+        )
 
 
 class AsyncLamResourceWithStreamingResponse:
     def __init__(self, lam: AsyncLamResource) -> None:
         self._lam = lam
 
-        self.extract = async_to_streamed_response_wrapper(
-            lam.extract,
-        )
-        self.integration_run = async_to_streamed_response_wrapper(
-            lam.integration_run,
-        )
         self.run = async_to_streamed_response_wrapper(
             lam.run,
         )
+        self.tasks = async_to_streamed_response_wrapper(
+            lam.tasks,
+        )