kernel 0.50.0__tar.gz → 0.52.0__tar.gz

kernel-0.52.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.52.0"
+}

{kernel-0.50.0 → kernel-0.52.0}/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 0.52.0 (2026-04-29)
+
+Full Changelog: [v0.51.0...v0.52.0](https://github.com/kernel/kernel-python-sdk/compare/v0.51.0...v0.52.0)
+
+### Features
+
+* profile download: 409 for empty profile + surface API errors in dashboard ([fd0c20e](https://github.com/kernel/kernel-python-sdk/commit/fd0c20eb17f0a6df382672c34830a81fac9217d9))
+* support setting headers via env ([37dda88](https://github.com/kernel/kernel-python-sdk/commit/37dda88a1f88fdf4bd8da615cbb6be1aadae3f41))
+
+
+### Bug Fixes
+
+* use correct field name format for multipart file arrays ([663f0a8](https://github.com/kernel/kernel-python-sdk/commit/663f0a8a633fd5b0f5f8b65ed169c4d780251e1d))
+
+
+### Documentation
+
+* annotate response with httpx.Response in browser routing example ([0dfa1fb](https://github.com/kernel/kernel-python-sdk/commit/0dfa1fb978da1c4fd474840ae8664f027e1feb39))
+* print buffered body and mention httpx.Response semantics ([84cb2e3](https://github.com/kernel/kernel-python-sdk/commit/84cb2e38486f330635487ed049d692f7c9716a1f))
+* show both raw streaming and buffered curl in routing example ([407e748](https://github.com/kernel/kernel-python-sdk/commit/407e74862f99db13320ea6c02a8752759d4de60a))
+* simplify browser routing example ([58b0ee2](https://github.com/kernel/kernel-python-sdk/commit/58b0ee27cdac1f4021c6e333f8157318c838ec56))
+
+## 0.51.0 (2026-04-25)
+
+Full Changelog: [v0.50.0...v0.51.0](https://github.com/kernel/kernel-python-sdk/compare/v0.50.0...v0.51.0)
+
+### Features
+
+* add browser-scoped session client ([7ca6887](https://github.com/kernel/kernel-python-sdk/commit/7ca68877e7011bb83862b7cc810a20d8254ea7dd))
+* Expire stuck IN_PROGRESS managed auth sessions via background worker ([7781a3b](https://github.com/kernel/kernel-python-sdk/commit/7781a3b4635ded02dea60adf85878f50f7b7fb27))
+* Expose browser_session_id on managed auth connection ([0ccb507](https://github.com/kernel/kernel-python-sdk/commit/0ccb50744032b4c31e0575fa7b06fb20503c8f55))
+* generate browser-scoped resource bindings ([53b17c8](https://github.com/kernel/kernel-python-sdk/commit/53b17c8241cc71261d1e96f5929cbd4f05b2064b))
+
+
+### Bug Fixes
+
+* address python browser routing ci follow-ups ([9690923](https://github.com/kernel/kernel-python-sdk/commit/9690923666cfe07de76267eee050d7743a8bad6f))
+* evict deleted browser routes ([a873a18](https://github.com/kernel/kernel-python-sdk/commit/a873a18eba3f36937dc177ab981372e395722f8b))
+* finish python browser routing cleanup ([694907a](https://github.com/kernel/kernel-python-sdk/commit/694907ab3419477e7058b85a7365ac4cce941105))
+* normalize browser route cache session IDs ([f4c247b](https://github.com/kernel/kernel-python-sdk/commit/f4c247b425680b54d0ce3c7738fb82313bca7918))
+* normalize python browser request string bodies ([3ce80e7](https://github.com/kernel/kernel-python-sdk/commit/3ce80e767d373b638ba1c2959bf18bf999629db0))
+* quiet generator-script pyright noise ([0bdf85e](https://github.com/kernel/kernel-python-sdk/commit/0bdf85e0c38d4813056b61599273e88c7a64713a))
+* reserve internal browser request query params ([b2c7aac](https://github.com/kernel/kernel-python-sdk/commit/b2c7aacac09a1bb7680cf493e9985438b169286c))
+* satisfy browser-scoped lint checks ([8e8dde2](https://github.com/kernel/kernel-python-sdk/commit/8e8dde241c8817944baaacd155fe196f200868e8))
+* satisfy generated browser-scoped type checks ([b410245](https://github.com/kernel/kernel-python-sdk/commit/b410245e1ad4bf8e29c17c59a5931654567b141f))
+* sniff browser pool route cache updates ([5328730](https://github.com/kernel/kernel-python-sdk/commit/532873072f0400029768d1b7cf54b9fb1428ada9))
+* type-check browser-scoped helpers ([cfff5b4](https://github.com/kernel/kernel-python-sdk/commit/cfff5b4c3635d327dd1ac0779d4e17e395efbec0))
+
+
+### Chores
+
+* fix browser-scoped test import order ([fc34859](https://github.com/kernel/kernel-python-sdk/commit/fc34859c4f60f84038b425d9930c512e58134dea))
+* **internal:** more robust bootstrap script ([6c9cdf3](https://github.com/kernel/kernel-python-sdk/commit/6c9cdf3ce828fab358c7e060f4e3313408cad257))
+* keep browser-scoped generator lint clean ([a80716b](https://github.com/kernel/kernel-python-sdk/commit/a80716b791bf1f707aa7869290c47caefb0d9e27))
+
+
+### Documentation
+
+* flesh out browser-scoped example ([ca5d188](https://github.com/kernel/kernel-python-sdk/commit/ca5d1884b590634df5623945e9585e0a66228ec3))
+
+
+### Refactors
+
+* clean up python browser routing diff ([622f844](https://github.com/kernel/kernel-python-sdk/commit/622f8448a8a32f00b41d6e4890bfaf0a9374bd3e))
+* drop browser-scoped wrapper clients ([dba503e](https://github.com/kernel/kernel-python-sdk/commit/dba503e832d54aa8d462d3d74b3027f8a9e865b6))
+* inline browser resource passthrough returns ([02a2f59](https://github.com/kernel/kernel-python-sdk/commit/02a2f595c7e76ae7f0cea2ec1e88075df3a25be1))
+* move python browser routing rollout to env ([0647d5c](https://github.com/kernel/kernel-python-sdk/commit/0647d5cab166e680bcb3436d1b502c3215492400))
+* rename browser routing subresources config ([3ae9dab](https://github.com/kernel/kernel-python-sdk/commit/3ae9dab6b841e6f1191cdde073e36696f97feb39))
+* simplify browser routing cache ([de0476f](https://github.com/kernel/kernel-python-sdk/commit/de0476fc043df48a58dd4067bb4b3c0fe7a83f0e))
+* sniff browser routes in response hooks ([563de7d](https://github.com/kernel/kernel-python-sdk/commit/563de7d0ac8f141320edb060b4671935808e473a))
+
 ## 0.50.0 (2026-04-20)
 
 Full Changelog: [v0.49.0...v0.50.0](https://github.com/kernel/kernel-python-sdk/compare/v0.49.0...v0.50.0)

{kernel-0.50.0 → kernel-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kernel
-Version: 0.50.0
+Version: 0.52.0
 Summary: The official Python library for the kernel API
 Project-URL: Homepage, https://github.com/kernel/kernel-python-sdk
 Project-URL: Repository, https://github.com/kernel/kernel-python-sdk

kernel-0.52.0/examples/browser_routing.py

@@ -0,0 +1,26 @@
+"""Example: direct-to-VM browser routing for raw HTTP."""
+
+import httpx
+
+from kernel import Kernel
+
+
+def main() -> None:
+    client = Kernel()
+
+    browser = client.browsers.create()
+
+    # Raw browser curl: streams the response. Use for large responses, when you want to stream,
+    # or when you want httpx.Response semantics.
+    response: httpx.Response = client.browsers.request(browser.session_id, "GET", "https://example.com")
+    print("status", response.status_code)
+
+    # Buffered browser curl: returns the full response in a JSON envelope. Use for small responses.
+    buffered = client.browsers.curl(browser.session_id, url="https://example.com", method="GET")
+    print("body", buffered.body)
+
+    client.browsers.delete_by_id(browser.session_id)
+
+
+if __name__ == "__main__":
+    main()

{kernel-0.50.0 → kernel-0.52.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kernel"
-version = "0.50.0"
+version = "0.52.0"
 description = "The official Python library for the kernel API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{kernel-0.50.0 → kernel-0.52.0}/src/kernel/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import TYPE_CHECKING, Any, Dict, Mapping, cast
+from typing import TYPE_CHECKING, Any, Dict, Type, Mapping, cast
 from typing_extensions import Self, Literal, override
 
 import httpx
@@ -14,13 +14,19 @@ from ._types import (
     Omit,
     Timeout,
     NotGiven,
+    ResponseT,
     Transport,
     ProxiesTypes,
     RequestOptions,
     not_given,
 )
-from ._utils import is_given, get_async_library
+from ._utils import (
+    is_given,
+    is_mapping_t,
+    get_async_library,
+)
 from ._compat import cached_property
+from ._models import FinalRequestOptions
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import KernelError, APIStatusError
@@ -29,6 +35,15 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .lib.browser_routing.routing import (
+    BrowserRouteCache,
+    BrowserRoutingConfig,
+    strip_direct_vm_auth,
+    rewrite_direct_vm_options,
+    browser_routing_config_from_env,
+    maybe_evict_browser_route_from_response,
+    maybe_populate_browser_route_cache_from_response,
+)
 
 if TYPE_CHECKING:
     from .resources import (
@@ -79,8 +94,10 @@ ENVIRONMENTS: Dict[str, str] = {
 class Kernel(SyncAPIClient):
     # client options
     api_key: str
+    browser_route_cache: BrowserRouteCache
 
     _environment: Literal["production", "development"] | NotGiven
+    _browser_routing: BrowserRoutingConfig
 
     def __init__(
         self,
@@ -105,6 +122,7 @@ class Kernel(SyncAPIClient):
         # outlining your use-case to help us decide if it should be
         # part of our public interface in the future.
         _strict_response_validation: bool = False,
+        _browser_route_cache: BrowserRouteCache | None = None,
     ) -> None:
         """Construct a new synchronous Kernel client instance.
 
@@ -144,6 +162,15 @@ class Kernel(SyncAPIClient):
             except KeyError as exc:
                 raise ValueError(f"Unknown environment: {environment}") from exc
 
+        custom_headers_env = os.environ.get("KERNEL_CUSTOM_HEADERS")
+        if custom_headers_env is not None:
+            parsed: dict[str, str] = {}
+            for line in custom_headers_env.split("\n"):
+                colon = line.find(":")
+                if colon >= 0:
+                    parsed[line[:colon].strip()] = line[colon + 1 :].strip()
+            default_headers = {**parsed, **(default_headers if is_mapping_t(default_headers) else {})}
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -154,6 +181,8 @@ class Kernel(SyncAPIClient):
             custom_query=default_query,
             _strict_response_validation=_strict_response_validation,
         )
+        self.browser_route_cache = _browser_route_cache or BrowserRouteCache()
+        self._browser_routing = browser_routing_config_from_env()
 
     @cached_property
     def deployments(self) -> DeploymentsResource:
@@ -266,6 +295,37 @@ class Kernel(SyncAPIClient):
             **self._custom_headers,
         }
 
+    @override
+    def _prepare_options(self, options: Any) -> Any:
+        options = cast(Any, super()._prepare_options(options))
+        return rewrite_direct_vm_options(options, cache=self.browser_route_cache, config=self._browser_routing)
+
+    @override
+    def _prepare_request(self, request: httpx.Request) -> None:
+        strip_direct_vm_auth(request, cache=self.browser_route_cache)
+
+    @override
+    def _process_response(
+        self,
+        *,
+        cast_to: Type[ResponseT],
+        options: FinalRequestOptions,
+        response: httpx.Response,
+        stream: bool,
+        stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None,
+        retries_taken: int = 0,
+    ) -> ResponseT:
+        maybe_populate_browser_route_cache_from_response(response, cache=self.browser_route_cache)
+        maybe_evict_browser_route_from_response(response, cache=self.browser_route_cache)
+        return super()._process_response(
+            cast_to=cast_to,
+            options=options,
+            response=response,
+            stream=stream,
+            stream_cls=stream_cls,
+            retries_taken=retries_taken,
+        )
+
     def copy(
         self,
         *,
@@ -279,6 +339,7 @@ class Kernel(SyncAPIClient):
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         set_default_query: Mapping[str, object] | None = None,
+        _browser_route_cache: BrowserRouteCache | None = None,
         _extra_kwargs: Mapping[str, Any] = {},
     ) -> Self:
         """
@@ -312,6 +373,7 @@ class Kernel(SyncAPIClient):
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,
+            _browser_route_cache=_browser_route_cache or self.browser_route_cache,
             **_extra_kwargs,
         )
 
@@ -356,8 +418,10 @@ class Kernel(SyncAPIClient):
 class AsyncKernel(AsyncAPIClient):
     # client options
     api_key: str
+    browser_route_cache: BrowserRouteCache
 
     _environment: Literal["production", "development"] | NotGiven
+    _browser_routing: BrowserRoutingConfig
 
     def __init__(
         self,
@@ -382,6 +446,7 @@ class AsyncKernel(AsyncAPIClient):
         # outlining your use-case to help us decide if it should be
         # part of our public interface in the future.
         _strict_response_validation: bool = False,
+        _browser_route_cache: BrowserRouteCache | None = None,
     ) -> None:
         """Construct a new async AsyncKernel client instance.
 
@@ -421,6 +486,15 @@ class AsyncKernel(AsyncAPIClient):
             except KeyError as exc:
                 raise ValueError(f"Unknown environment: {environment}") from exc
 
+        custom_headers_env = os.environ.get("KERNEL_CUSTOM_HEADERS")
+        if custom_headers_env is not None:
+            parsed: dict[str, str] = {}
+            for line in custom_headers_env.split("\n"):
+                colon = line.find(":")
+                if colon >= 0:
+                    parsed[line[:colon].strip()] = line[colon + 1 :].strip()
+            default_headers = {**parsed, **(default_headers if is_mapping_t(default_headers) else {})}
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -431,6 +505,8 @@ class AsyncKernel(AsyncAPIClient):
             custom_query=default_query,
             _strict_response_validation=_strict_response_validation,
         )
+        self.browser_route_cache = _browser_route_cache or BrowserRouteCache()
+        self._browser_routing = browser_routing_config_from_env()
 
     @cached_property
     def deployments(self) -> AsyncDeploymentsResource:
@@ -543,6 +619,37 @@ class AsyncKernel(AsyncAPIClient):
             **self._custom_headers,
         }
 
+    @override
+    async def _prepare_options(self, options: Any) -> Any:
+        options = cast(Any, await super()._prepare_options(options))
+        return rewrite_direct_vm_options(options, cache=self.browser_route_cache, config=self._browser_routing)
+
+    @override
+    async def _prepare_request(self, request: httpx.Request) -> None:
+        strip_direct_vm_auth(request, cache=self.browser_route_cache)
+
+    @override
+    async def _process_response(
+        self,
+        *,
+        cast_to: Type[ResponseT],
+        options: FinalRequestOptions,
+        response: httpx.Response,
+        stream: bool,
+        stream_cls: type[Stream[Any]] | type[AsyncStream[Any]] | None,
+        retries_taken: int = 0,
+    ) -> ResponseT:
+        maybe_populate_browser_route_cache_from_response(response, cache=self.browser_route_cache)
+        maybe_evict_browser_route_from_response(response, cache=self.browser_route_cache)
+        return await super()._process_response(
+            cast_to=cast_to,
+            options=options,
+            response=response,
+            stream=stream,
+            stream_cls=stream_cls,
+            retries_taken=retries_taken,
+        )
+
     def copy(
         self,
         *,
@@ -556,6 +663,7 @@ class AsyncKernel(AsyncAPIClient):
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         set_default_query: Mapping[str, object] | None = None,
+        _browser_route_cache: BrowserRouteCache | None = None,
         _extra_kwargs: Mapping[str, Any] = {},
     ) -> Self:
         """
@@ -589,6 +697,7 @@ class AsyncKernel(AsyncAPIClient):
             max_retries=max_retries if is_given(max_retries) else self.max_retries,
             default_headers=headers,
             default_query=params,
+            _browser_route_cache=_browser_route_cache or self.browser_route_cache,
             **_extra_kwargs,
         )
 

{kernel-0.50.0 → kernel-0.52.0}/src/kernel/_qs.py

@@ -2,17 +2,13 @@ from __future__ import annotations
 
 from typing import Any, List, Tuple, Union, Mapping, TypeVar
 from urllib.parse import parse_qs, urlencode
-from typing_extensions import Literal, get_args
+from typing_extensions import get_args
 
-from ._types import NotGiven, not_given
+from ._types import NotGiven, ArrayFormat, NestedFormat, not_given
 from ._utils import flatten
 
 _T = TypeVar("_T")
 
-
-ArrayFormat = Literal["comma", "repeat", "indices", "brackets"]
-NestedFormat = Literal["dots", "brackets"]
-
 PrimitiveData = Union[str, int, float, bool, None]
 # this should be Data = Union[PrimitiveData, "List[Data]", "Tuple[Data]", "Mapping[str, Data]"]
 # https://github.com/microsoft/pyright/issues/3555

{kernel-0.50.0 → kernel-0.52.0}/src/kernel/_types.py

@@ -47,6 +47,9 @@ AnyMapping = Mapping[str, object]
 ModelT = TypeVar("ModelT", bound=pydantic.BaseModel)
 _T = TypeVar("_T")
 
+ArrayFormat = Literal["comma", "repeat", "indices", "brackets"]
+NestedFormat = Literal["dots", "brackets"]
+
 
 # Approximates httpx internal ProxiesTypes and RequestFiles types
 # while adding support for `PathLike` instances

{kernel-0.50.0 → kernel-0.52.0}/src/kernel/_utils/_utils.py

@@ -17,11 +17,11 @@ from typing import (
 )
 from pathlib import Path
 from datetime import date, datetime
-from typing_extensions import TypeGuard
+from typing_extensions import TypeGuard, get_args
 
 import sniffio
 
-from .._types import Omit, NotGiven, FileTypes, HeadersLike
+from .._types import Omit, NotGiven, FileTypes, ArrayFormat, HeadersLike
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])
@@ -40,25 +40,45 @@ def extract_files(
     query: Mapping[str, object],
     *,
     paths: Sequence[Sequence[str]],
+    array_format: ArrayFormat = "brackets",
 ) -> list[tuple[str, FileTypes]]:
     """Recursively extract files from the given dictionary based on specified paths.
 
     A path may look like this ['foo', 'files', '<array>', 'data'].
 
+    ``array_format`` controls how ``<array>`` segments contribute to the emitted
+    field name. Supported values: ``"brackets"`` (``foo[]``), ``"repeat"`` and
+    ``"comma"`` (``foo``), ``"indices"`` (``foo[0]``, ``foo[1]``).
+
     Note: this mutates the given dictionary.
     """
     files: list[tuple[str, FileTypes]] = []
     for path in paths:
-        files.extend(_extract_items(query, path, index=0, flattened_key=None))
+        files.extend(_extract_items(query, path, index=0, flattened_key=None, array_format=array_format))
     return files
 
 
+def _array_suffix(array_format: ArrayFormat, array_index: int) -> str:
+    if array_format == "brackets":
+        return "[]"
+    if array_format == "indices":
+        return f"[{array_index}]"
+    if array_format == "repeat" or array_format == "comma":
+        # Both repeat the bare field name for each file part; there is no
+        # meaningful way to comma-join binary parts.
+        return ""
+    raise NotImplementedError(
+        f"Unknown array_format value: {array_format}, choose from {', '.join(get_args(ArrayFormat))}"
+    )
+
+
 def _extract_items(
     obj: object,
     path: Sequence[str],
     *,
     index: int,
     flattened_key: str | None,
+    array_format: ArrayFormat,
 ) -> list[tuple[str, FileTypes]]:
     try:
         key = path[index]
@@ -75,9 +95,11 @@ def _extract_items(
 
         if is_list(obj):
             files: list[tuple[str, FileTypes]] = []
-            for entry in obj:
-                assert_is_file_content(entry, key=flattened_key + "[]" if flattened_key else "")
-                files.append((flattened_key + "[]", cast(FileTypes, entry)))
+            for array_index, entry in enumerate(obj):
+                suffix = _array_suffix(array_format, array_index)
+                emitted_key = (flattened_key + suffix) if flattened_key else suffix
+                assert_is_file_content(entry, key=emitted_key)
+                files.append((emitted_key, cast(FileTypes, entry)))
             return files
 
         assert_is_file_content(obj, key=flattened_key)
@@ -106,6 +128,7 @@ def _extract_items(
             path,
             index=index,
             flattened_key=flattened_key,
+            array_format=array_format,
         )
     elif is_list(obj):
         if key != "<array>":
@@ -117,9 +140,12 @@ def _extract_items(
                     item,
                     path,
                     index=index,
-                    flattened_key=flattened_key + "[]" if flattened_key is not None else "[]",
+                    flattened_key=(
+                        (flattened_key if flattened_key is not None else "") + _array_suffix(array_format, array_index)
+                    ),
+                    array_format=array_format,
                 )
-                for item in obj
+                for array_index, item in enumerate(obj)
             ]
         )
 

{kernel-0.50.0 → kernel-0.52.0}/src/kernel/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "kernel"
-__version__ = "0.50.0"  # x-release-please-version
+__version__ = "0.52.0"  # x-release-please-version

kernel-0.52.0/src/kernel/lib/browser_routing/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__all__: list[str] = []

kernel-0.52.0/src/kernel/lib/browser_routing/raw_http.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import IO, Any, Union, Mapping, cast
+from contextlib import contextmanager, asynccontextmanager
+from collections.abc import Iterable, Iterator, AsyncIterator
+
+import httpx
+
+from .util import sanitize_curl_raw_params
+from .routing import BrowserRoute
+from ..._types import Body, Timeout, NotGiven, not_given
+from ..._models import FinalRequestOptions
+
+BrowserRawContent = Union[bytes, bytearray, memoryview, str, IO[bytes], Iterable[bytes]]
+
+
+def request_via_browser_route(
+    parent: Any,
+    route: BrowserRoute,
+    method: str,
+    url: str,
+    *,
+    content: BrowserRawContent | None = None,
+    json: Body | None = None,
+    headers: Mapping[str, str] | None = None,
+    params: Mapping[str, object] | None = None,
+    timeout: float | Timeout | None | NotGiven = not_given,
+) -> httpx.Response:
+    if json is not None and content is not None:
+        raise TypeError("Passing both `json` and `content` is not supported")
+    query: dict[str, object] = {**sanitize_curl_raw_params(params), "url": url, "jwt": route.jwt}
+    options = FinalRequestOptions.construct(
+        method=method.upper(),
+        url=route.base_url.rstrip("/") + "/curl/raw",
+        params=query,
+        headers=headers or {},
+        content=_normalize_binary_content(content),
+        json_data=json,
+        timeout=_normalize_timeout(timeout),
+    )
+    return cast(httpx.Response, parent.request(httpx.Response, options))
+
+
+@contextmanager
+def stream_via_browser_route(
+    parent: Any,
+    route: BrowserRoute,
+    method: str,
+    url: str,
+    *,
+    content: BrowserRawContent | None = None,
+    headers: Mapping[str, str] | None = None,
+    params: Mapping[str, object] | None = None,
+    timeout: float | Timeout | None | NotGiven = not_given,
+) -> Iterator[httpx.Response]:
+    query: dict[str, Any] = sanitize_curl_raw_params(params)
+    query["jwt"] = route.jwt
+    query["url"] = url
+    request_headers = {k: v for k, v in parent.default_headers.items() if isinstance(v, str)}
+    if content is None:
+        request_headers.pop("Content-Type", None)
+    if headers:
+        request_headers.update(headers)
+    request_headers.pop("Authorization", None)
+    effective_timeout = parent.timeout if isinstance(timeout, NotGiven) else timeout
+    with parent._client.stream(
+        method.upper(),
+        route.base_url.rstrip("/") + "/curl/raw",
+        params=query,
+        headers=request_headers,
+        content=_normalize_binary_content(content),
+        timeout=_normalize_timeout(effective_timeout),
+    ) as response:
+        yield response
+
+
+async def async_request_via_browser_route(
+    parent: Any,
+    route: BrowserRoute,
+    method: str,
+    url: str,
+    *,
+    content: BrowserRawContent | None = None,
+    json: Body | None = None,
+    headers: Mapping[str, str] | None = None,
+    params: Mapping[str, object] | None = None,
+    timeout: float | Timeout | None | NotGiven = not_given,
+) -> httpx.Response:
+    if json is not None and content is not None:
+        raise TypeError("Passing both `json` and `content` is not supported")
+    query: dict[str, object] = {**sanitize_curl_raw_params(params), "url": url, "jwt": route.jwt}
+    options = FinalRequestOptions.construct(
+        method=method.upper(),
+        url=route.base_url.rstrip("/") + "/curl/raw",
+        params=query,
+        headers=headers or {},
+        content=_normalize_binary_content(content),
+        json_data=json,
+        timeout=_normalize_timeout(timeout),
+    )
+    return cast(httpx.Response, await parent.request(httpx.Response, options))
+
+
+@asynccontextmanager
+async def async_stream_via_browser_route(
+    parent: Any,
+    route: BrowserRoute,
+    method: str,
+    url: str,
+    *,
+    content: BrowserRawContent | None = None,
+    headers: Mapping[str, str] | None = None,
+    params: Mapping[str, object] | None = None,
+    timeout: float | Timeout | None | NotGiven = not_given,
+) -> AsyncIterator[httpx.Response]:
+    query: dict[str, Any] = sanitize_curl_raw_params(params)
+    query["jwt"] = route.jwt
+    query["url"] = url
+    request_headers = {k: v for k, v in parent.default_headers.items() if isinstance(v, str)}
+    if content is None:
+        request_headers.pop("Content-Type", None)
+    if headers:
+        request_headers.update(headers)
+    request_headers.pop("Authorization", None)
+    effective_timeout = parent.timeout if isinstance(timeout, NotGiven) else timeout
+    async with parent._client.stream(
+        method.upper(),
+        route.base_url.rstrip("/") + "/curl/raw",
+        params=query,
+        headers=request_headers,
+        content=_normalize_binary_content(content),
+        timeout=_normalize_timeout(effective_timeout),
+    ) as response:
+        yield response
+
+
+def _normalize_timeout(timeout: float | Timeout | None | NotGiven) -> float | Timeout | None:
+    return None if isinstance(timeout, NotGiven) else timeout
+
+
+def _normalize_binary_content(content: BrowserRawContent | None) -> bytes | IO[bytes] | Iterable[bytes] | None:
+    if content is None:
+        return None
+    if isinstance(content, str):
+        return content.encode()
+    if isinstance(content, bytearray):
+        return bytes(content)
+    if isinstance(content, memoryview):
+        return content.tobytes()
+    return content