diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 7ed8b9a..554e34b 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "0.29.1"
+  ".": "0.30.0"
 }
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index f4db3cd..86b0bd0 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 8
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/perplexity-ai%2Fperplexity-78325ecc9bdc8e9850866fcdd3be3d209b06f151059c774afc7e6005a1775f09.yml
-openapi_spec_hash: 19a34c8ddd46f81dd0b0850af5ee42f3
-config_hash: c3b93f1bb8fa365d5a83e83b7e13e6c4
+configured_endpoints: 10
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/perplexity-ai%2Fperplexity-e5052719572f5155f4cf704d996e5c7a875700a16f68f2335975ea3d06140b17.yml
+openapi_spec_hash: 97d9df5dc228bb6d71be54212bc5b600
+config_hash: e09a1767e929614701fb498eaaac682d
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 19ac971..2a095d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.30.0 (2026-02-23)
+
+Full Changelog: [v0.29.1...v0.30.0](https://github.com/perplexityai/perplexity-py/compare/v0.29.1...v0.30.0)
+
+### Features
+
+* **api:** Add browser and sandbox API endpoints ([f5c3e58](https://github.com/perplexityai/perplexity-py/commit/f5c3e58836feb37a6b9ba366a55811513a8cd28c))
+* **api:** manual updates ([a556321](https://github.com/perplexityai/perplexity-py/commit/a556321ac2ed946bfeccc9912dd20ee71349a34a))
+
+
+### Chores
+
+* **internal:** add request options to SSE classes ([b18a992](https://github.com/perplexityai/perplexity-py/commit/b18a992a0eedca20c38932809e1056dfb8c5b00e))
+* **internal:** remove mock server code ([081b00d](https://github.com/perplexityai/perplexity-py/commit/081b00d6a86f95631caacd16a46ea91c8f6d97b9))
+* update mock server docs ([d6f9a54](https://github.com/perplexityai/perplexity-py/commit/d6f9a5428ecb632baea8705f4eadc1225ba5a9fd))
+
 ## 0.29.1 (2026-02-12)
 
 Full Changelog: [v0.29.0...v0.29.1](https://github.com/perplexityai/perplexity-py/compare/v0.29.0...v0.29.1)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 186f1c3..f50b0f4 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -85,13 +85,6 @@ $ pip install ./path-to-wheel-file.whl
 
 ## Running tests
 
-Most tests require you to [set up a mock server](https://github.com/stoplightio/prism) against the OpenAPI spec to run the tests.
-
-```sh
-# you will need npm installed
-$ npx prism mock path/to/your/openapi.yml
-```
-
 ```sh
 $ ./scripts/test
 ```
diff --git a/api.md b/api.md
index 9884d1d..24ee260 100644
--- a/api.md
+++ b/api.md
@@ -3,6 +3,7 @@
 ```python
 from perplexity.types import (
     APIPublicSearchResult,
+    BrowserSessionResponse,
     ChatMessageInput,
     ChatMessageOutput,
     Choice,
@@ -92,6 +93,15 @@ Methods:
 
 - <code title="post /v1/contextualizedembeddings">client.contextualized_embeddings.<a href="./src/perplexity/resources/contextualized_embeddings.py">create</a>(\*\*<a href="src/perplexity/types/contextualized_embedding_create_params.py">params</a>) -> <a href="./src/perplexity/types/contextualized_embedding_create_response.py">ContextualizedEmbeddingCreateResponse</a></code>
 
+# Browser
+
+## Sessions
+
+Methods:
+
+- <code title="post /v1/browser/sessions">client.browser.sessions.<a href="./src/perplexity/resources/browser/sessions.py">create</a>() -> <a href="./src/perplexity/types/shared/browser_session_response.py">BrowserSessionResponse</a></code>
+- <code title="delete /v1/browser/sessions/{session_id}">client.browser.sessions.<a href="./src/perplexity/resources/browser/sessions.py">delete</a>(session_id) -> None</code>
+
 # Async
 
 ## Chat
diff --git a/pyproject.toml b/pyproject.toml
index 0105782..6cd026c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "perplexityai"
-version = "0.29.1"
+version = "0.30.0"
 description = "The official Python library for the perplexity API"
 dynamic = ["readme"]
 license = "Apache-2.0"
diff --git a/scripts/mock b/scripts/mock
deleted file mode 100755
index 0b28f6e..0000000
--- a/scripts/mock
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-cd "$(dirname "$0")/.."
-
-if [[ -n "$1" && "$1" != '--'* ]]; then
-  URL="$1"
-  shift
-else
-  URL="$(grep 'openapi_spec_url' .stats.yml | cut -d' ' -f2)"
-fi
-
-# Check if the URL is empty
-if [ -z "$URL" ]; then
-  echo "Error: No OpenAPI spec path/url provided or found in .stats.yml"
-  exit 1
-fi
-
-echo "==> Starting mock server with URL ${URL}"
-
-# Run prism mock on the given spec
-if [ "$1" == "--daemon" ]; then
-  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log &
-
-  # Wait for server to come online
-  echo -n "Waiting for server"
-  while ! grep -q "✖  fatal\|Prism is listening" ".prism.log" ; do
-    echo -n "."
-    sleep 0.1
-  done
-
-  if grep -q "✖  fatal" ".prism.log"; then
-    cat .prism.log
-    exit 1
-  fi
-
-  echo
-else
-  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL"
-fi
diff --git a/scripts/test b/scripts/test
index dbeda2d..39729d0 100755
--- a/scripts/test
+++ b/scripts/test
@@ -4,53 +4,7 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-NC='\033[0m' # No Color
 
-function prism_is_running() {
-  curl --silent "http://localhost:4010" >/dev/null 2>&1
-}
-
-kill_server_on_port() {
-  pids=$(lsof -t -i tcp:"$1" || echo "")
-  if [ "$pids" != "" ]; then
-    kill "$pids"
-    echo "Stopped $pids."
-  fi
-}
-
-function is_overriding_api_base_url() {
-  [ -n "$TEST_API_BASE_URL" ]
-}
-
-if ! is_overriding_api_base_url && ! prism_is_running ; then
-  # When we exit this script, make sure to kill the background mock server process
-  trap 'kill_server_on_port 4010' EXIT
-
-  # Start the dev server
-  ./scripts/mock --daemon
-fi
-
-if is_overriding_api_base_url ; then
-  echo -e "${GREEN}✔ Running tests against ${TEST_API_BASE_URL}${NC}"
-  echo
-elif ! prism_is_running ; then
-  echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Prism server"
-  echo -e "running against your OpenAPI spec."
-  echo
-  echo -e "To run the server, pass in the path or url of your OpenAPI"
-  echo -e "spec to the prism command:"
-  echo
-  echo -e "  \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}"
-  echo
-
-  exit 1
-else
-  echo -e "${GREEN}✔ Mock prism server is running with your OpenAPI spec${NC}"
-  echo
-fi
 
 export DEFER_PYDANTIC_BUILD=false
 
diff --git a/src/perplexity/_client.py b/src/perplexity/_client.py
index bd84502..eec3b46 100644
--- a/src/perplexity/_client.py
+++ b/src/perplexity/_client.py
@@ -31,12 +31,13 @@
 )
 
 if TYPE_CHECKING:
-    from .resources import chat, async_, search, responses, embeddings, contextualized_embeddings
+    from .resources import chat, async_, search, browser, responses, embeddings, contextualized_embeddings
     from .resources.search import SearchResource, AsyncSearchResource
     from .resources.chat.chat import ChatResource, AsyncChatResource
     from .resources.responses import ResponsesResource, AsyncResponsesResource
     from .resources.embeddings import EmbeddingsResource, AsyncEmbeddingsResource
     from .resources.async_.async_ import AsyncResource, AsyncAsyncResource
+    from .resources.browser.browser import BrowserResource, AsyncBrowserResource
     from .resources.contextualized_embeddings import (
         ContextualizedEmbeddingsResource,
         AsyncContextualizedEmbeddingsResource,
@@ -141,6 +142,12 @@ def contextualized_embeddings(self) -> ContextualizedEmbeddingsResource:
 
         return ContextualizedEmbeddingsResource(self)
 
+    @cached_property
+    def browser(self) -> BrowserResource:
+        from .resources.browser import BrowserResource
+
+        return BrowserResource(self)
+
     @cached_property
     def async_(self) -> AsyncResource:
         from .resources.async_ import AsyncResource
@@ -347,6 +354,12 @@ def contextualized_embeddings(self) -> AsyncContextualizedEmbeddingsResource:
 
         return AsyncContextualizedEmbeddingsResource(self)
 
+    @cached_property
+    def browser(self) -> AsyncBrowserResource:
+        from .resources.browser import AsyncBrowserResource
+
+        return AsyncBrowserResource(self)
+
     @cached_property
     def async_(self) -> AsyncAsyncResource:
         from .resources.async_ import AsyncAsyncResource
@@ -502,6 +515,12 @@ def contextualized_embeddings(self) -> contextualized_embeddings.ContextualizedE
 
         return ContextualizedEmbeddingsResourceWithRawResponse(self._client.contextualized_embeddings)
 
+    @cached_property
+    def browser(self) -> browser.BrowserResourceWithRawResponse:
+        from .resources.browser import BrowserResourceWithRawResponse
+
+        return BrowserResourceWithRawResponse(self._client.browser)
+
     @cached_property
     def async_(self) -> async_.AsyncResourceWithRawResponse:
         from .resources.async_ import AsyncResourceWithRawResponse
@@ -547,6 +566,12 @@ def contextualized_embeddings(
 
         return AsyncContextualizedEmbeddingsResourceWithRawResponse(self._client.contextualized_embeddings)
 
+    @cached_property
+    def browser(self) -> browser.AsyncBrowserResourceWithRawResponse:
+        from .resources.browser import AsyncBrowserResourceWithRawResponse
+
+        return AsyncBrowserResourceWithRawResponse(self._client.browser)
+
     @cached_property
     def async_(self) -> async_.AsyncAsyncResourceWithRawResponse:
         from .resources.async_ import AsyncAsyncResourceWithRawResponse
@@ -592,6 +617,12 @@ def contextualized_embeddings(
 
         return ContextualizedEmbeddingsResourceWithStreamingResponse(self._client.contextualized_embeddings)
 
+    @cached_property
+    def browser(self) -> browser.BrowserResourceWithStreamingResponse:
+        from .resources.browser import BrowserResourceWithStreamingResponse
+
+        return BrowserResourceWithStreamingResponse(self._client.browser)
+
     @cached_property
     def async_(self) -> async_.AsyncResourceWithStreamingResponse:
         from .resources.async_ import AsyncResourceWithStreamingResponse
@@ -637,6 +668,12 @@ def contextualized_embeddings(
 
         return AsyncContextualizedEmbeddingsResourceWithStreamingResponse(self._client.contextualized_embeddings)
 
+    @cached_property
+    def browser(self) -> browser.AsyncBrowserResourceWithStreamingResponse:
+        from .resources.browser import AsyncBrowserResourceWithStreamingResponse
+
+        return AsyncBrowserResourceWithStreamingResponse(self._client.browser)
+
     @cached_property
     def async_(self) -> async_.AsyncAsyncResourceWithStreamingResponse:
         from .resources.async_ import AsyncAsyncResourceWithStreamingResponse
diff --git a/src/perplexity/_response.py b/src/perplexity/_response.py
index e54740c..3c940cf 100644
--- a/src/perplexity/_response.py
+++ b/src/perplexity/_response.py
@@ -152,6 +152,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
                         ),
                         response=self.http_response,
                         client=cast(Any, self._client),
+                        options=self._options,
                     ),
                 )
 
@@ -162,6 +163,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
                         cast_to=extract_stream_chunk_type(self._stream_cls),
                         response=self.http_response,
                         client=cast(Any, self._client),
+                        options=self._options,
                     ),
                 )
 
@@ -175,6 +177,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
                     cast_to=cast_to,
                     response=self.http_response,
                     client=cast(Any, self._client),
+                    options=self._options,
                 ),
             )
 
diff --git a/src/perplexity/_streaming.py b/src/perplexity/_streaming.py
index 29fa5e0..1c93aa6 100644
--- a/src/perplexity/_streaming.py
+++ b/src/perplexity/_streaming.py
@@ -4,7 +4,7 @@
 import json
 import inspect
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, Iterator, AsyncIterator, cast
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, Iterator, Optional, AsyncIterator, cast
 from typing_extensions import Self, Protocol, TypeGuard, override, get_origin, runtime_checkable
 
 import httpx
@@ -13,6 +13,7 @@
 
 if TYPE_CHECKING:
     from ._client import Perplexity, AsyncPerplexity
+    from ._models import FinalRequestOptions
 
 
 _T = TypeVar("_T")
@@ -22,7 +23,7 @@ class Stream(Generic[_T]):
     """Provides the core interface to iterate over a synchronous stream response."""
 
     response: httpx.Response
-
+    _options: Optional[FinalRequestOptions] = None
     _decoder: SSEBytesDecoder
 
     def __init__(
@@ -31,10 +32,12 @@ def __init__(
         cast_to: type[_T],
         response: httpx.Response,
         client: Perplexity,
+        options: Optional[FinalRequestOptions] = None,
     ) -> None:
         self.response = response
         self._cast_to = cast_to
         self._client = client
+        self._options = options
         self._decoder = client._make_sse_decoder()
         self._iterator = self.__stream__()
 
@@ -104,7 +107,7 @@ class AsyncStream(Generic[_T]):
     """Provides the core interface to iterate over an asynchronous stream response."""
 
     response: httpx.Response
-
+    _options: Optional[FinalRequestOptions] = None
     _decoder: SSEDecoder | SSEBytesDecoder
 
     def __init__(
@@ -113,10 +116,12 @@ def __init__(
         cast_to: type[_T],
         response: httpx.Response,
         client: AsyncPerplexity,
+        options: Optional[FinalRequestOptions] = None,
     ) -> None:
         self.response = response
         self._cast_to = cast_to
         self._client = client
+        self._options = options
         self._decoder = client._make_sse_decoder()
         self._iterator = self.__stream__()
 
diff --git a/src/perplexity/_version.py b/src/perplexity/_version.py
index a0c5adf..aca4a94 100644
--- a/src/perplexity/_version.py
+++ b/src/perplexity/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "perplexity"
-__version__ = "0.29.1"  # x-release-please-version
+__version__ = "0.30.0"  # x-release-please-version
diff --git a/src/perplexity/resources/__init__.py b/src/perplexity/resources/__init__.py
index 30b55b6..17f6793 100644
--- a/src/perplexity/resources/__init__.py
+++ b/src/perplexity/resources/__init__.py
@@ -24,6 +24,14 @@
     SearchResourceWithStreamingResponse,
     AsyncSearchResourceWithStreamingResponse,
 )
+from .browser import (
+    BrowserResource,
+    AsyncBrowserResource,
+    BrowserResourceWithRawResponse,
+    AsyncBrowserResourceWithRawResponse,
+    BrowserResourceWithStreamingResponse,
+    AsyncBrowserResourceWithStreamingResponse,
+)
 from .responses import (
     ResponsesResource,
     AsyncResponsesResource,
@@ -80,6 +88,12 @@
     "AsyncContextualizedEmbeddingsResourceWithRawResponse",
     "ContextualizedEmbeddingsResourceWithStreamingResponse",
     "AsyncContextualizedEmbeddingsResourceWithStreamingResponse",
+    "BrowserResource",
+    "AsyncBrowserResource",
+    "BrowserResourceWithRawResponse",
+    "AsyncBrowserResourceWithRawResponse",
+    "BrowserResourceWithStreamingResponse",
+    "AsyncBrowserResourceWithStreamingResponse",
     "AsyncResource",
     "AsyncAsyncResource",
     "AsyncResourceWithRawResponse",
diff --git a/src/perplexity/resources/browser/__init__.py b/src/perplexity/resources/browser/__init__.py
new file mode 100644
index 0000000..e401ff7
--- /dev/null
+++ b/src/perplexity/resources/browser/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .browser import (
+    BrowserResource,
+    AsyncBrowserResource,
+    BrowserResourceWithRawResponse,
+    AsyncBrowserResourceWithRawResponse,
+    BrowserResourceWithStreamingResponse,
+    AsyncBrowserResourceWithStreamingResponse,
+)
+from .sessions import (
+    SessionsResource,
+    AsyncSessionsResource,
+    SessionsResourceWithRawResponse,
+    AsyncSessionsResourceWithRawResponse,
+    SessionsResourceWithStreamingResponse,
+    AsyncSessionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "SessionsResource",
+    "AsyncSessionsResource",
+    "SessionsResourceWithRawResponse",
+    "AsyncSessionsResourceWithRawResponse",
+    "SessionsResourceWithStreamingResponse",
+    "AsyncSessionsResourceWithStreamingResponse",
+    "BrowserResource",
+    "AsyncBrowserResource",
+    "BrowserResourceWithRawResponse",
+    "AsyncBrowserResourceWithRawResponse",
+    "BrowserResourceWithStreamingResponse",
+    "AsyncBrowserResourceWithStreamingResponse",
+]
diff --git a/src/perplexity/resources/browser/browser.py b/src/perplexity/resources/browser/browser.py
new file mode 100644
index 0000000..378e5a5
--- /dev/null
+++ b/src/perplexity/resources/browser/browser.py
@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .sessions import (
+    SessionsResource,
+    AsyncSessionsResource,
+    SessionsResourceWithRawResponse,
+    AsyncSessionsResourceWithRawResponse,
+    SessionsResourceWithStreamingResponse,
+    AsyncSessionsResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["BrowserResource", "AsyncBrowserResource"]
+
+
+class BrowserResource(SyncAPIResource):
+    @cached_property
+    def sessions(self) -> SessionsResource:
+        return SessionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> BrowserResourceWithRawResponse:
+        """
+        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/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return BrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BrowserResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return BrowserResourceWithStreamingResponse(self)
+
+
+class AsyncBrowserResource(AsyncAPIResource):
+    @cached_property
+    def sessions(self) -> AsyncSessionsResource:
+        return AsyncSessionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBrowserResourceWithRawResponse:
+        """
+        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/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBrowserResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return AsyncBrowserResourceWithStreamingResponse(self)
+
+
+class BrowserResourceWithRawResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+    @cached_property
+    def sessions(self) -> SessionsResourceWithRawResponse:
+        return SessionsResourceWithRawResponse(self._browser.sessions)
+
+
+class AsyncBrowserResourceWithRawResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsResourceWithRawResponse:
+        return AsyncSessionsResourceWithRawResponse(self._browser.sessions)
+
+
+class BrowserResourceWithStreamingResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+    @cached_property
+    def sessions(self) -> SessionsResourceWithStreamingResponse:
+        return SessionsResourceWithStreamingResponse(self._browser.sessions)
+
+
+class AsyncBrowserResourceWithStreamingResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsResourceWithStreamingResponse:
+        return AsyncSessionsResourceWithStreamingResponse(self._browser.sessions)
diff --git a/src/perplexity/resources/browser/sessions.py b/src/perplexity/resources/browser/sessions.py
new file mode 100644
index 0000000..6655ba5
--- /dev/null
+++ b/src/perplexity/resources/browser/sessions.py
@@ -0,0 +1,217 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..._types import Body, Query, Headers, NoneType, NotGiven, not_given
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..._base_client import make_request_options
+from ...types.shared.browser_session_response import BrowserSessionResponse
+
+__all__ = ["SessionsResource", "AsyncSessionsResource"]
+
+
+class SessionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SessionsResourceWithRawResponse:
+        """
+        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/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return SessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return SessionsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        # 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,
+    ) -> BrowserSessionResponse:
+        """Create a new remote browser session for CDP-based automation."""
+        return self._post(
+            "/v1/browser/sessions",
+            body={},
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BrowserSessionResponse,
+        )
+
+    def delete(
+        self,
+        session_id: 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,
+    ) -> None:
+        """
+        Stop and clean up a remote browser session.
+
+        Args:
+          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
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/v1/browser/sessions/{session_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncSessionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSessionsResourceWithRawResponse:
+        """
+        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/perplexityai/perplexity-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/perplexityai/perplexity-py#with_streaming_response
+        """
+        return AsyncSessionsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        # 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,
+    ) -> BrowserSessionResponse:
+        """Create a new remote browser session for CDP-based automation."""
+        return await self._post(
+            "/v1/browser/sessions",
+            body={},
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BrowserSessionResponse,
+        )
+
+    async def delete(
+        self,
+        session_id: 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,
+    ) -> None:
+        """
+        Stop and clean up a remote browser session.
+
+        Args:
+          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
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/v1/browser/sessions/{session_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class SessionsResourceWithRawResponse:
+    def __init__(self, sessions: SessionsResource) -> None:
+        self._sessions = sessions
+
+        self.create = to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.delete = to_raw_response_wrapper(
+            sessions.delete,
+        )
+
+
+class AsyncSessionsResourceWithRawResponse:
+    def __init__(self, sessions: AsyncSessionsResource) -> None:
+        self._sessions = sessions
+
+        self.create = async_to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            sessions.delete,
+        )
+
+
+class SessionsResourceWithStreamingResponse:
+    def __init__(self, sessions: SessionsResource) -> None:
+        self._sessions = sessions
+
+        self.create = to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.delete = to_streamed_response_wrapper(
+            sessions.delete,
+        )
+
+
+class AsyncSessionsResourceWithStreamingResponse:
+    def __init__(self, sessions: AsyncSessionsResource) -> None:
+        self._sessions = sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            sessions.delete,
+        )
diff --git a/src/perplexity/types/__init__.py b/src/perplexity/types/__init__.py
index a9b252f..dcd0ffa 100644
--- a/src/perplexity/types/__init__.py
+++ b/src/perplexity/types/__init__.py
@@ -15,6 +15,7 @@
     WebSearchOptions as WebSearchOptions,
     ChatMessageOutput as ChatMessageOutput,
     APIPublicSearchResult as APIPublicSearchResult,
+    BrowserSessionResponse as BrowserSessionResponse,
     ContextualizedEmbeddingObject as ContextualizedEmbeddingObject,
 )
 from .annotation import Annotation as Annotation
diff --git a/src/perplexity/types/browser/__init__.py b/src/perplexity/types/browser/__init__.py
new file mode 100644
index 0000000..f8ee8b1
--- /dev/null
+++ b/src/perplexity/types/browser/__init__.py
@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
diff --git a/src/perplexity/types/shared/__init__.py b/src/perplexity/types/shared/__init__.py
index 4a3fa01..73a229b 100644
--- a/src/perplexity/types/shared/__init__.py
+++ b/src/perplexity/types/shared/__init__.py
@@ -12,4 +12,5 @@
 from .web_search_options import WebSearchOptions as WebSearchOptions
 from .chat_message_output import ChatMessageOutput as ChatMessageOutput
 from .api_public_search_result import APIPublicSearchResult as APIPublicSearchResult
+from .browser_session_response import BrowserSessionResponse as BrowserSessionResponse
 from .contextualized_embedding_object import ContextualizedEmbeddingObject as ContextualizedEmbeddingObject
diff --git a/src/perplexity/types/shared/browser_session_response.py b/src/perplexity/types/shared/browser_session_response.py
new file mode 100644
index 0000000..c5ed327
--- /dev/null
+++ b/src/perplexity/types/shared/browser_session_response.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BrowserSessionResponse"]
+
+
+class BrowserSessionResponse(BaseModel):
+    """Response containing browser session details"""
+
+    session_id: Optional[str] = None
+    """Unique identifier for the browser session"""
+
+    status: Optional[Literal["running", "stopped"]] = None
+    """Current status of the session"""
diff --git a/tests/api_resources/async_/chat/test_completions.py b/tests/api_resources/async_/chat/test_completions.py
index 6e9f901..7f7cead 100644
--- a/tests/api_resources/async_/chat/test_completions.py
+++ b/tests/api_resources/async_/chat/test_completions.py
@@ -21,7 +21,7 @@
 class TestCompletions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create(self, client: Perplexity) -> None:
         completion = client.async_.chat.completions.create(
@@ -37,7 +37,7 @@ def test_method_create(self, client: Perplexity) -> None:
         )
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Perplexity) -> None:
         completion = client.async_.chat.completions.create(
@@ -183,7 +183,7 @@ def test_method_create_with_all_params(self, client: Perplexity) -> None:
         )
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Perplexity) -> None:
         response = client.async_.chat.completions.with_raw_response.create(
@@ -203,7 +203,7 @@ def test_raw_response_create(self, client: Perplexity) -> None:
         completion = response.parse()
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Perplexity) -> None:
         with client.async_.chat.completions.with_streaming_response.create(
@@ -225,13 +225,13 @@ def test_streaming_response_create(self, client: Perplexity) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_list(self, client: Perplexity) -> None:
         completion = client.async_.chat.completions.list()
         assert_matches_type(CompletionListResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Perplexity) -> None:
         response = client.async_.chat.completions.with_raw_response.list()
@@ -241,7 +241,7 @@ def test_raw_response_list(self, client: Perplexity) -> None:
         completion = response.parse()
         assert_matches_type(CompletionListResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Perplexity) -> None:
         with client.async_.chat.completions.with_streaming_response.list() as response:
@@ -253,7 +253,7 @@ def test_streaming_response_list(self, client: Perplexity) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_get(self, client: Perplexity) -> None:
         completion = client.async_.chat.completions.get(
@@ -261,7 +261,7 @@ def test_method_get(self, client: Perplexity) -> None:
         )
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_get_with_all_params(self, client: Perplexity) -> None:
         completion = client.async_.chat.completions.get(
@@ -276,7 +276,7 @@ def test_method_get_with_all_params(self, client: Perplexity) -> None:
         )
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_get(self, client: Perplexity) -> None:
         response = client.async_.chat.completions.with_raw_response.get(
@@ -288,7 +288,7 @@ def test_raw_response_get(self, client: Perplexity) -> None:
         completion = response.parse()
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_get(self, client: Perplexity) -> None:
         with client.async_.chat.completions.with_streaming_response.get(
@@ -302,7 +302,7 @@ def test_streaming_response_get(self, client: Perplexity) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_path_params_get(self, client: Perplexity) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `api_request` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncCompletions:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.async_.chat.completions.create(
@@ -332,7 +332,7 @@ async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         )
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.async_.chat.completions.create(
@@ -478,7 +478,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPerplexity
         )
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.async_.chat.completions.with_raw_response.create(
@@ -498,7 +498,7 @@ async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         completion = await response.parse()
         assert_matches_type(CompletionCreateResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncPerplexity) -> None:
         async with async_client.async_.chat.completions.with_streaming_response.create(
@@ -520,13 +520,13 @@ async def test_streaming_response_create(self, async_client: AsyncPerplexity) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.async_.chat.completions.list()
         assert_matches_type(CompletionListResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.async_.chat.completions.with_raw_response.list()
@@ -536,7 +536,7 @@ async def test_raw_response_list(self, async_client: AsyncPerplexity) -> None:
         completion = await response.parse()
         assert_matches_type(CompletionListResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncPerplexity) -> None:
         async with async_client.async_.chat.completions.with_streaming_response.list() as response:
@@ -548,7 +548,7 @@ async def test_streaming_response_list(self, async_client: AsyncPerplexity) -> N
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_get(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.async_.chat.completions.get(
@@ -556,7 +556,7 @@ async def test_method_get(self, async_client: AsyncPerplexity) -> None:
         )
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_get_with_all_params(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.async_.chat.completions.get(
@@ -571,7 +571,7 @@ async def test_method_get_with_all_params(self, async_client: AsyncPerplexity) -
         )
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.async_.chat.completions.with_raw_response.get(
@@ -583,7 +583,7 @@ async def test_raw_response_get(self, async_client: AsyncPerplexity) -> None:
         completion = await response.parse()
         assert_matches_type(CompletionGetResponse, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncPerplexity) -> None:
         async with async_client.async_.chat.completions.with_streaming_response.get(
@@ -597,7 +597,7 @@ async def test_streaming_response_get(self, async_client: AsyncPerplexity) -> No
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncPerplexity) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `api_request` but received ''"):
diff --git a/tests/api_resources/browser/__init__.py b/tests/api_resources/browser/__init__.py
new file mode 100644
index 0000000..fd8019a
--- /dev/null
+++ b/tests/api_resources/browser/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/browser/test_sessions.py b/tests/api_resources/browser/test_sessions.py
new file mode 100644
index 0000000..e45506d
--- /dev/null
+++ b/tests/api_resources/browser/test_sessions.py
@@ -0,0 +1,164 @@
+# 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 perplexity import Perplexity, AsyncPerplexity
+from tests.utils import assert_matches_type
+from perplexity.types.shared import BrowserSessionResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestSessions:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_method_create(self, client: Perplexity) -> None:
+        session = client.browser.sessions.create()
+        assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_raw_response_create(self, client: Perplexity) -> None:
+        response = client.browser.sessions.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_streaming_response_create(self, client: Perplexity) -> None:
+        with client.browser.sessions.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = response.parse()
+            assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_method_delete(self, client: Perplexity) -> None:
+        session = client.browser.sessions.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert session is None
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_raw_response_delete(self, client: Perplexity) -> None:
+        response = client.browser.sessions.with_raw_response.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert session is None
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_streaming_response_delete(self, client: Perplexity) -> None:
+        with client.browser.sessions.with_streaming_response.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = response.parse()
+            assert session is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_path_params_delete(self, client: Perplexity) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `session_id` but received ''"):
+            client.browser.sessions.with_raw_response.delete(
+                "",
+            )
+
+
+class TestAsyncSessions:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_method_create(self, async_client: AsyncPerplexity) -> None:
+        session = await async_client.browser.sessions.create()
+        assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
+        response = await async_client.browser.sessions.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = await response.parse()
+        assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncPerplexity) -> None:
+        async with async_client.browser.sessions.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = await response.parse()
+            assert_matches_type(BrowserSessionResponse, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncPerplexity) -> None:
+        session = await async_client.browser.sessions.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert session is None
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncPerplexity) -> None:
+        response = await async_client.browser.sessions.with_raw_response.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = await response.parse()
+        assert session is None
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncPerplexity) -> None:
+        async with async_client.browser.sessions.with_streaming_response.delete(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = await response.parse()
+            assert session is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncPerplexity) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `session_id` but received ''"):
+            await async_client.browser.sessions.with_raw_response.delete(
+                "",
+            )
diff --git a/tests/api_resources/chat/test_completions.py b/tests/api_resources/chat/test_completions.py
index ec771a4..d46424b 100644
--- a/tests/api_resources/chat/test_completions.py
+++ b/tests/api_resources/chat/test_completions.py
@@ -17,7 +17,7 @@
 class TestCompletions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_overload_1(self, client: Perplexity) -> None:
         completion = client.chat.completions.create(
@@ -31,7 +31,7 @@ def test_method_create_overload_1(self, client: Perplexity) -> None:
         )
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params_overload_1(self, client: Perplexity) -> None:
         completion = client.chat.completions.create(
@@ -174,7 +174,7 @@ def test_method_create_with_all_params_overload_1(self, client: Perplexity) -> N
         )
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create_overload_1(self, client: Perplexity) -> None:
         response = client.chat.completions.with_raw_response.create(
@@ -192,7 +192,7 @@ def test_raw_response_create_overload_1(self, client: Perplexity) -> None:
         completion = response.parse()
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create_overload_1(self, client: Perplexity) -> None:
         with client.chat.completions.with_streaming_response.create(
@@ -212,7 +212,7 @@ def test_streaming_response_create_overload_1(self, client: Perplexity) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_overload_2(self, client: Perplexity) -> None:
         completion_stream = client.chat.completions.create(
@@ -227,7 +227,7 @@ def test_method_create_overload_2(self, client: Perplexity) -> None:
         )
         completion_stream.response.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params_overload_2(self, client: Perplexity) -> None:
         completion_stream = client.chat.completions.create(
@@ -370,7 +370,7 @@ def test_method_create_with_all_params_overload_2(self, client: Perplexity) -> N
         )
         completion_stream.response.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create_overload_2(self, client: Perplexity) -> None:
         response = client.chat.completions.with_raw_response.create(
@@ -388,7 +388,7 @@ def test_raw_response_create_overload_2(self, client: Perplexity) -> None:
         stream = response.parse()
         stream.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create_overload_2(self, client: Perplexity) -> None:
         with client.chat.completions.with_streaming_response.create(
@@ -415,7 +415,7 @@ class TestAsyncCompletions:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.chat.completions.create(
@@ -429,7 +429,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPerplexity) ->
         )
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPerplexity) -> None:
         completion = await async_client.chat.completions.create(
@@ -572,7 +572,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
         )
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.chat.completions.with_raw_response.create(
@@ -590,7 +590,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPerplexit
         completion = await response.parse()
         assert_matches_type(StreamChunk, completion, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         async with async_client.chat.completions.with_streaming_response.create(
@@ -610,7 +610,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPer
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         completion_stream = await async_client.chat.completions.create(
@@ -625,7 +625,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPerplexity) ->
         )
         await completion_stream.response.aclose()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params_overload_2(self, async_client: AsyncPerplexity) -> None:
         completion_stream = await async_client.chat.completions.create(
@@ -768,7 +768,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
         )
         await completion_stream.response.aclose()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.chat.completions.with_raw_response.create(
@@ -786,7 +786,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPerplexit
         stream = await response.parse()
         await stream.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         async with async_client.chat.completions.with_streaming_response.create(
diff --git a/tests/api_resources/test_contextualized_embeddings.py b/tests/api_resources/test_contextualized_embeddings.py
index b81ab77..1325ff8 100644
--- a/tests/api_resources/test_contextualized_embeddings.py
+++ b/tests/api_resources/test_contextualized_embeddings.py
@@ -17,7 +17,7 @@
 class TestContextualizedEmbeddings:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create(self, client: Perplexity) -> None:
         contextualized_embedding = client.contextualized_embeddings.create(
@@ -26,7 +26,7 @@ def test_method_create(self, client: Perplexity) -> None:
         )
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Perplexity) -> None:
         contextualized_embedding = client.contextualized_embeddings.create(
@@ -37,7 +37,7 @@ def test_method_create_with_all_params(self, client: Perplexity) -> None:
         )
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Perplexity) -> None:
         response = client.contextualized_embeddings.with_raw_response.create(
@@ -50,7 +50,7 @@ def test_raw_response_create(self, client: Perplexity) -> None:
         contextualized_embedding = response.parse()
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Perplexity) -> None:
         with client.contextualized_embeddings.with_streaming_response.create(
@@ -71,7 +71,7 @@ class TestAsyncContextualizedEmbeddings:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         contextualized_embedding = await async_client.contextualized_embeddings.create(
@@ -80,7 +80,7 @@ async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         )
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncPerplexity) -> None:
         contextualized_embedding = await async_client.contextualized_embeddings.create(
@@ -91,7 +91,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPerplexity
         )
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.contextualized_embeddings.with_raw_response.create(
@@ -104,7 +104,7 @@ async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         contextualized_embedding = await response.parse()
         assert_matches_type(ContextualizedEmbeddingCreateResponse, contextualized_embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncPerplexity) -> None:
         async with async_client.contextualized_embeddings.with_streaming_response.create(
diff --git a/tests/api_resources/test_embeddings.py b/tests/api_resources/test_embeddings.py
index 94e9cdd..28229d9 100644
--- a/tests/api_resources/test_embeddings.py
+++ b/tests/api_resources/test_embeddings.py
@@ -17,7 +17,7 @@
 class TestEmbeddings:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create(self, client: Perplexity) -> None:
         embedding = client.embeddings.create(
@@ -26,7 +26,7 @@ def test_method_create(self, client: Perplexity) -> None:
         )
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Perplexity) -> None:
         embedding = client.embeddings.create(
@@ -37,7 +37,7 @@ def test_method_create_with_all_params(self, client: Perplexity) -> None:
         )
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Perplexity) -> None:
         response = client.embeddings.with_raw_response.create(
@@ -50,7 +50,7 @@ def test_raw_response_create(self, client: Perplexity) -> None:
         embedding = response.parse()
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Perplexity) -> None:
         with client.embeddings.with_streaming_response.create(
@@ -71,7 +71,7 @@ class TestAsyncEmbeddings:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         embedding = await async_client.embeddings.create(
@@ -80,7 +80,7 @@ async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         )
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncPerplexity) -> None:
         embedding = await async_client.embeddings.create(
@@ -91,7 +91,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPerplexity
         )
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.embeddings.with_raw_response.create(
@@ -104,7 +104,7 @@ async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         embedding = await response.parse()
         assert_matches_type(EmbeddingCreateResponse, embedding, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncPerplexity) -> None:
         async with async_client.embeddings.with_streaming_response.create(
diff --git a/tests/api_resources/test_responses.py b/tests/api_resources/test_responses.py
index 2933f6e..a47c20b 100644
--- a/tests/api_resources/test_responses.py
+++ b/tests/api_resources/test_responses.py
@@ -17,7 +17,7 @@
 class TestResponses:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_overload_1(self, client: Perplexity) -> None:
         response = client.responses.create(
@@ -25,7 +25,7 @@ def test_method_create_overload_1(self, client: Perplexity) -> None:
         )
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params_overload_1(self, client: Perplexity) -> None:
         response = client.responses.create(
@@ -73,7 +73,7 @@ def test_method_create_with_all_params_overload_1(self, client: Perplexity) -> N
         )
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create_overload_1(self, client: Perplexity) -> None:
         http_response = client.responses.with_raw_response.create(
@@ -85,7 +85,7 @@ def test_raw_response_create_overload_1(self, client: Perplexity) -> None:
         response = http_response.parse()
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create_overload_1(self, client: Perplexity) -> None:
         with client.responses.with_streaming_response.create(
@@ -99,7 +99,7 @@ def test_streaming_response_create_overload_1(self, client: Perplexity) -> None:
 
         assert cast(Any, http_response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_overload_2(self, client: Perplexity) -> None:
         response_stream = client.responses.create(
@@ -108,7 +108,7 @@ def test_method_create_overload_2(self, client: Perplexity) -> None:
         )
         response_stream.response.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params_overload_2(self, client: Perplexity) -> None:
         response_stream = client.responses.create(
@@ -156,7 +156,7 @@ def test_method_create_with_all_params_overload_2(self, client: Perplexity) -> N
         )
         response_stream.response.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create_overload_2(self, client: Perplexity) -> None:
         response = client.responses.with_raw_response.create(
@@ -168,7 +168,7 @@ def test_raw_response_create_overload_2(self, client: Perplexity) -> None:
         stream = response.parse()
         stream.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create_overload_2(self, client: Perplexity) -> None:
         with client.responses.with_streaming_response.create(
@@ -189,7 +189,7 @@ class TestAsyncResponses:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.responses.create(
@@ -197,7 +197,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPerplexity) ->
         )
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.responses.create(
@@ -245,7 +245,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
         )
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         http_response = await async_client.responses.with_raw_response.create(
@@ -257,7 +257,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPerplexit
         response = await http_response.parse()
         assert_matches_type(ResponseCreateResponse, response, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create_overload_1(self, async_client: AsyncPerplexity) -> None:
         async with async_client.responses.with_streaming_response.create(
@@ -271,7 +271,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPer
 
         assert cast(Any, http_response.is_closed) is True
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         response_stream = await async_client.responses.create(
@@ -280,7 +280,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPerplexity) ->
         )
         await response_stream.response.aclose()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params_overload_2(self, async_client: AsyncPerplexity) -> None:
         response_stream = await async_client.responses.create(
@@ -328,7 +328,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
         )
         await response_stream.response.aclose()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.responses.with_raw_response.create(
@@ -340,7 +340,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPerplexit
         stream = await response.parse()
         await stream.close()
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create_overload_2(self, async_client: AsyncPerplexity) -> None:
         async with async_client.responses.with_streaming_response.create(
diff --git a/tests/api_resources/test_search.py b/tests/api_resources/test_search.py
index 2f62378..7bcd539 100644
--- a/tests/api_resources/test_search.py
+++ b/tests/api_resources/test_search.py
@@ -17,7 +17,7 @@
 class TestSearch:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create(self, client: Perplexity) -> None:
         search = client.search.create(
@@ -25,7 +25,7 @@ def test_method_create(self, client: Perplexity) -> None:
         )
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Perplexity) -> None:
         search = client.search.create(
@@ -46,7 +46,7 @@ def test_method_create_with_all_params(self, client: Perplexity) -> None:
         )
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Perplexity) -> None:
         response = client.search.with_raw_response.create(
@@ -58,7 +58,7 @@ def test_raw_response_create(self, client: Perplexity) -> None:
         search = response.parse()
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Perplexity) -> None:
         with client.search.with_streaming_response.create(
@@ -78,7 +78,7 @@ class TestAsyncSearch:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         search = await async_client.search.create(
@@ -86,7 +86,7 @@ async def test_method_create(self, async_client: AsyncPerplexity) -> None:
         )
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncPerplexity) -> None:
         search = await async_client.search.create(
@@ -107,7 +107,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPerplexity
         )
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         response = await async_client.search.with_raw_response.create(
@@ -119,7 +119,7 @@ async def test_raw_response_create(self, async_client: AsyncPerplexity) -> None:
         search = await response.parse()
         assert_matches_type(SearchCreateResponse, search, path=["response"])
 
-    @pytest.mark.skip(reason="Prism tests are disabled")
+    @pytest.mark.skip(reason="Mock server tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncPerplexity) -> None:
         async with async_client.search.with_streaming_response.create(