Ë
    ñÏjà  ã                  ó¸  — d Z ddlmZ ddlZddlZddlZddlZddlmZm	Z	 ddl
mZmZmZmZmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= ddl>m?Z?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF erddlGmHZH dd„ZIdd„ZJee	eKeKf      ZL G d„ d«      ZMy)zFAsync SandboxClient class for interacting with the sandbox server API.é    )ÚannotationsN)ÚCallableÚMapping)ÚTYPE_CHECKINGÚAnyÚOptionalÚUnionÚoverload)Úutils)ÚAsyncLangsmith)Úhttpx)Ú_get_openapi_base_url)ÚAccessDelegationÚ_validate_access_delegation)ÚAsyncSandbox)ÚSandboxClientÚ_box_urlÚ_make_docker_context_tarÚ_make_dockerfile_build_commandÚ_quote_path_segmentÚ_quote_reference_segmentÚ_resolve_dockerfile_context)ÚResourceCreationErrorÚResourceNameConflictErrorÚResourceNotFoundErrorÚResourceTimeoutErrorÚSandboxAPIError)Úhandle_client_http_errorÚhandle_sandbox_creation_errorÚmerge_headersÚraise_if_not_readyÚvalidate_service_paramsÚvalidate_ttl)
ÚAsyncServiceURLÚDownloadContentDispositionÚDownloadURLÚResourceStatusÚ	RunConfigÚServiceAccessÚServiceLoginURLÚSnapshotÚSnapshotTagÚ_run_config_payload)ÚSandboxMountConfigÚ"validate_mount_config_proxy_config)ÚSandboxProxyConfig)Úadd_sandbox_metadata)ÚAsyncRetryTransport)ÚAsyncRegistriesResourcec                 óL   — t        j                  dd¬«      } t        | «      › d�S )z†Get the default sandbox API endpoint from environment.

    Derives the endpoint from LANGSMITH_ENDPOINT (or LANGCHAIN_ENDPOINT).
    ÚENDPOINTzhttps://api.smith.langchain.com)Údefaultz/api/v2/sandboxes)Úls_utilsÚget_env_varr   )Úbases    ú\/var/www/html/gaurav-v2/venv/lib/python3.12/site-packages/langsmith/sandbox/_async_client.pyÚ_get_default_api_endpointr;   G   s+   € ô
 ×Ñ 
Ð4UÔV€DÜ# DÓ)Ð*Ð*;Ð<Ð<ó    c                 ó,   — t        j                  d«      S )z)Get the default API key from environment.ÚAPI_KEY)r7   r8   © r<   r:   Ú_get_default_api_keyr@   P   s   € ä×Ñ 	Ó*Ð*r<   c                  ór  — e Zd ZdZddddddœ	 	 	 	 	 	 	 	 	 d?d„Zd@d„ZdAd„ZdBd	„ZedCd
„«       Z	dDd„Z
dDd„ZdEd„ZdFd„ZdFd„ZdGd„Z	 	 	 	 	 	 	 	 dHd„ZdBd„Z	 dIddddddddddddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dJd„Z	 dIddddddddddddddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dKd„Zddœ	 	 	 	 	 dLd„Zddœ	 	 	 dMd„Zdddddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dNd„Zddœ	 	 	 	 	 dOd„Zddœ	 	 	 	 	 dPd„Zed ddd!œ	 	 	 	 	 	 	 	 	 	 	 dQd"„«       Zed dd#œ	 	 	 	 	 	 	 	 	 	 	 dRd$„«       Zd ddd!œ	 	 	 	 	 	 	 	 	 	 	 dSd%„Zddddd&œ	 	 	 	 	 	 	 	 	 	 	 	 	 dTd'„Zd(d)dd*œ	 	 	 	 	 	 	 	 	 dUd+„Zd(dd,œ	 	 	 	 	 	 	 dVd-„ZddœdOd.„Zdddd/dd0œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dWd1„Z	 dId2dddddd/dd3œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dXd4„Z ddddd/dd5œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dYd6„Z!ddœ	 	 	 	 	 dZd7„Z"ddœ	 	 	 	 	 d[d8„Z#ddddd9œ	 	 	 	 	 	 	 	 	 d\d:„Z$ddœ	 	 	 	 	 d]d;„Z%d<d=dd*œ	 	 	 	 	 	 	 	 	 d^d>„Z&y)_ÚAsyncSandboxClienta  Async client for interacting with the Sandbox Server API.

    This client provides an async interface for managing sandboxes and snapshots.

    Example:
        # Uses LANGSMITH_ENDPOINT and LANGSMITH_API_KEY from environment
        async with AsyncSandboxClient() as client:
            # Create a sandbox with the default runtime and run commands
            async with await client.sandbox() as sandbox:
                result = await sandbox.run("python --version")
                print(result.stdout)
    Ng      $@é   ©Úapi_endpointÚtimeoutÚapi_keyÚmax_retriesÚheadersc               óz  — |xs
 t        «       j                  d«      | _        |xs
 t        «       }|| _        || _        || _        i | _        |rt        |«      ni | _	        i }|r||d<   | j                  rt        || j                  «      }t        |¬«      }t        j                  |||¬«      | _        d| _        y)a®  Initialize the AsyncSandboxClient.

        Args:
            api_endpoint: Full URL of the sandbox API endpoint. If not provided,
                          derived from LANGSMITH_ENDPOINT environment variable.
            timeout: Default HTTP timeout in seconds.
            api_key: API key for authentication. If not provided, uses
                     LANGSMITH_API_KEY environment variable.
            max_retries: Maximum number of retries for transient errors (502, 503,
                         504), rate limits (429), and connection failures. Set to 0
                         to disable retries. Default: 3.
            headers: Optional default headers attached to every request on this
                     client, including the data-plane ``/execute`` HTTP endpoint
                     and the ``/execute/ws`` WebSocket upgrade. Use this to pass
                     additional auth headers (e.g. ``X-Service-Key``).
        Ú/z	X-Api-Key)rH   )Ú	transportrF   rI   N)r;   ÚrstripÚ	_base_urlr@   Ú_api_keyÚ_timeoutÚ_max_retriesÚ_sandbox_idsÚdictÚ_default_headersr    r2   r   ÚAsyncClientÚ_httpÚ_registries_client)	ÚselfrE   rF   rG   rH   rI   Úresolved_api_keyÚclient_headersrL   s	            r:   Ú__init__zAsyncSandboxClient.__init__f   s·   € ð2 'ÒEÔ*CÓ*E×MÑMÈcÓRˆŒØ"Ò<Ô&:Ó&<ÐØ(ˆŒØˆŒØ'ˆÔØ,.ˆÔÙAH´°W´ÈbˆÔØ)+ˆÙØ*:ˆN˜;Ñ'Ø× Ò Ü*¨>¸4×;PÑ;PÓQˆNÜ'°KÔ@ˆ	Ü×&Ñ&Ø¨¸.ô
ˆŒ
ð =AˆÕr<   c                ó²   — | j                   j                  |«      }|€	 t        t        j                  |«      «      }t        |«       |S # t
        $ r Y Œw xY w)z5Attach metadata when the sandbox ID is already known.)rR   ÚgetÚstrÚuuidÚUUIDÚ
ValueErrorr1   )rX   ÚnameÚ
sandbox_ids      r:   Ú_trace_sandboxz!AsyncSandboxClient._trace_sandbox‘   sY   € à×&Ñ&×*Ñ*¨4Ó0ˆ
ØÐðÜ ¤§¡¨4£Ó1�
ô 	˜ZÔ(ØÐøô ò Ùðús   ŸA
 Á
	AÁAc                óÂ   — | j                   j                  ||«      }| j                   j                  «       D ��ci c]  \  }}||k7  r||k7  r||“Œ c}}| _         y c c}}w ©N)rR   r]   Úitems)rX   rb   rc   Úcached_nameÚ	cached_ids        r:   Ú_forget_sandboxz"AsyncSandboxClient._forget_sandboxœ   si   € Ø×&Ñ&×*Ñ*¨4°Ó6ˆ
ð +/×*;Ñ*;×*AÑ*AÔ*Cô
á*CÑ&�˜YØ˜dÒ" y°JÒ'>ð ˜Ñ"Ø*Cò
ˆÕùó 
s   ºAc                ó˜   — d}| j                   j                  |«      r"t        | j                   dt        |«        «      S | j                   S )z>Return the API root URL, without the ``/v2/sandboxes`` suffix.z/v2/sandboxesN)rN   Úendswithr   Úlen)rX   Úsuffixs     r:   Ú	_api_rootzAsyncSandboxClient._api_root¤   s?   € à ˆØ�>‰>×"Ñ" 6Ô*Ü(¨¯©¸¼3¸v»;¸,Ð)GÓHÐHØ�~‰~Ðr<   c                óÌ   — | j                   €9t        | j                  | j                  «       | j                  xs d¬«      | _         | j                   j
                  j                  S )aò  Manage sandbox image registries: create, list, retrieve, update, delete.

        A registry stores credentials for pulling private images. Create one,
        then pass its ``id`` as ``registry_id`` when building a snapshot.

        Example:
            registry = await client.registries.create(
                name="internal",
                url="registry.example.com",
                username="robot",
                password=os.environ["REGISTRY_PASSWORD"],
            )
            snapshot = await client.create_snapshot(
                "internal-python",
                docker_image="registry.example.com/internal/python:3.12",
                fs_capacity_bytes=2 * 1024**3,
                registry_id=registry.id,
            )
        N)rG   Úbase_urlÚdefault_headers)rW   r   rO   ro   rT   Ú	sandboxesÚ
registries©rX   s    r:   rt   zAsyncSandboxClient.registries«   sV   € ð* ×"Ñ"Ð*Ü&4ØŸ™ØŸ™Ó)Ø $× 5Ñ 5Ò =¸ô'ˆDÔ#ð
 ×&Ñ&×0Ñ0×;Ñ;Ð;r<   c                óH   — |€yt        | j                  j                  |«      S )z8Merge default client headers with per-request overrides.N)r    rV   rI   ©rX   rI   s     r:   Ú_request_headersz#AsyncSandboxClient._request_headersÈ   s!   € àˆ?ØÜ˜TŸZ™Z×/Ñ/°Ó9Ð9r<   c                óL   — | j                   s|€yt        | j                   |«      S )zÜMerge constructor-supplied default headers with per-request overrides.

        Used by the WebSocket exec path so headers like ``X-Service-Key``
        set on the client are attached to the WS upgrade request.
        N)rT   r    rw   s     r:   Ú_ws_default_headersz&AsyncSandboxClient._ws_default_headersÎ   s'   € ð ×$Ò$¨¨ØÜ˜T×2Ñ2°GÓ<Ð<r<   c                óŽ   — t        | j                  | j                  | j                  | j                  | j
                  xs d¬«      S )aC  Create a SandboxClient with the same configuration.

        The returned client has its own HTTP connection pool; close it
        independently (``client.close()`` or ``with``).

        Returns:
            SandboxClient with the same endpoint, credentials, timeout,
            retry, and header configuration.
        NrD   )r   rN   rP   rO   rQ   rT   ru   s    r:   Úto_synczAsyncSandboxClient.to_syncØ   s=   € ô ØŸ™Ø—M‘MØ—M‘MØ×)Ñ)Ø×)Ñ)Ò1¨Tô
ð 	
r<   c              ƒ  ó¶   K  — | j                   j                  «       ƒ d{  –—†  | j                  �#| j                  j                  «       ƒ d{  –—†  yy7 Œ47 Œ­w)zClose the async HTTP client.N)rV   ÚacloserW   Úcloseru   s    r:   r~   zAsyncSandboxClient.acloseê   sN   è ø€ à�j‰j×ÑÓ!×!Ð!Ø×"Ñ"Ð.Ø×)Ñ)×/Ñ/Ó1×1Ñ1ð /ð 	"øà1ús!   ‚A A¡-AÁAÁAÁAc                óú   — 	 | j                   j                  sF	 t        j                  «       }|j                  «       s |j	                  | j                  «       «       yyy# t        $ r Y yw xY w# t        $ r Y yw xY w)a$  Best-effort cleanup of the async HTTP client on garbage collection.

        If an event loop is running, schedules ``aclose()`` as a task.
        Otherwise the underlying sockets will be closed by the GC.
        For deterministic cleanup, use ``async with`` or ``await aclose()``.
        N)rV   Ú	is_closedÚasyncioÚget_running_loopÚcreate_taskr~   ÚRuntimeErrorÚ	Exception)rX   Úloops     r:   Ú__del__zAsyncSandboxClient.__del__ð   st   € ð		Ø—:‘:×'Ò'ðÜ"×3Ñ3Ó5�DØŸ>™>Ô+Ø×(Ñ(¨¯©«Õ7ð ,ð (øô
 $ò Ùðûäò 	Ùð	ús/   ‚A. ™AA Á	A+Á(A. Á*A+Á+A. Á.	A:Á9A:c              ƒ  ó   K  — | S ­w)zEnter async context manager.r?   ru   s    r:   Ú
__aenter__zAsyncSandboxClient.__aenter__  s   è ø€ àˆùs   ‚c              ƒ  ó@   K  — | j                  «       ƒ d{  –—†  y7 Œ­w)zExit async context manager.N)r~   )rX   Úexc_typeÚexc_valÚexc_tbs       r:   Ú	__aexit__zAsyncSandboxClient.__aexit__  s   è ø€ ð �k‰k‹m×Òús   ‚–—c                ó"   — d| j                   › d�S )z�Return a string representation of the instance.

        Returns:
            The string representation of the instance.
        zAsyncSandboxClient (API URL: Ú))rN   ru   s    r:   Ú__repr__zAsyncSandboxClient.__repr__  s   € ð /¨t¯~©~Ð.>¸aÐ@Ð@r<   é   ©ÚsnapshotÚsnapshot_namerb   rF   Úidle_ttl_secondsÚdelete_after_stop_secondsÚvcpusÚ	mem_bytesÚfs_capacity_bytesÚmount_configÚproxy_configÚ
run_configrI   c             ƒ  ón   K  — | j                  |||||||||	|
||||¬«      ƒ d{  –—† }d|_        |S 7 Œ­w)a	  Create a sandbox and return an AsyncSandbox instance.

        This is the primary method for creating sandboxes. Use it as an
        async context manager for automatic cleanup:

            async with await client.sandbox(snapshot_id="<uuid>") as sandbox:
                result = await sandbox.run("echo hello")

            # Resolve by snapshot name instead of ID:
            async with await client.sandbox(snapshot_name="my-snap") as sandbox:
                result = await sandbox.run("echo hello")

        The sandbox is automatically deleted when exiting the context manager.
        For sandboxes with manual lifecycle management, use create_sandbox().

        Args:
            snapshot_id: Optional snapshot ID to boot from. Mutually exclusive
                with ``snapshot`` and ``snapshot_name``.
            snapshot: Snapshot to boot from, as a UUID, ``name:tag``, or a bare
                ``name`` (which means ``name:latest``). Prefer this over
                ``snapshot_id`` and ``snapshot_name``: it covers all three forms.
            snapshot_name: Deprecated synonym for ``snapshot``, kept for callers
                that predate it.
            name: Optional sandbox name (auto-generated if not provided).
            timeout: Timeout in seconds when waiting for ready.
            idle_ttl_seconds: Idle timeout in seconds. The launcher
                automatically stops the sandbox after this duration of
                inactivity. Must be a multiple of 60. ``0`` explicitly
                disables the idle stop. When omitted (``None``), the server
                applies a default of ``600`` seconds (10 minutes).
            delete_after_stop_seconds: Seconds after the sandbox enters the
                ``stopped`` state before it (and its filesystem clone) are
                permanently deleted. Must be a multiple of 60. ``0`` disables
                stop-anchored deletion (manual cleanup required). When
                omitted (``None``), the server applies its configured default.
            vcpus: Number of vCPUs.
            mem_bytes: Memory in bytes.
            fs_capacity_bytes: Root filesystem capacity in bytes.
            mount_config: Mount configuration forwarded to the server as
                ``mount_config``. The backend expands mount auth into runtime
                proxy rules. Explicit AWS/GCP proxy rules in ``proxy_config``
                conflict with mount auth for the same provider.
            proxy_config: Per-sandbox proxy configuration forwarded to the
                server as-is. Shape matches the backend `proxy_config` field:
                ``{"rules": [...], "access_control":
                {"allow_list": [...]}}`` or ``{"access_control":
                {"deny_list": [...]}}``. Use ``access_control.allow_list`` to
                restrict outbound HTTPS to a set of host patterns (exact
                domains, globs like ``*.example.com``, IPs, CIDRs, or
                ``~regex``). Use ``proxy_config`` with provider rule helpers
                such as ``aws_auth`` to let the proxy sign supported
                AWS HTTPS requests on the sandbox's behalf.

        Returns:
            AsyncSandbox instance.

        Raises:
            ResourceTimeoutError: If timeout waiting for sandbox to be ready.
            ResourceCreationError: If sandbox creation fails.
            SandboxClientError: For other errors.
            ValueError: If TTL values are invalid, or if more than one of
                ``snapshot_id``, ``snapshot`` and ``snapshot_name`` is provided.
        r”   NT)Úcreate_sandboxÚ_auto_delete)rX   Úsnapshot_idr•   r–   rb   rF   r—   r˜   r™   rš   r›   rœ   r�   rž   rI   Úsbs                   r:   ÚsandboxzAsyncSandboxClient.sandbox  s`   è ø€ ðb ×&Ñ&ØØØ'ØØØ-Ø&?ØØØ/Ø%Ø%Ø!Øð 'ó 
÷ 
ˆð  ˆŒØˆ	ð#
ús   ‚#5¥3¦5T)r•   r–   rb   rF   Úwait_for_readyr—   r˜   r™   rš   r›   rœ   r�   rž   Úaccess_delegationrI   c             ƒ  ó~  K  — |xs |}|r|r||k7  rt        d«      ‚|r|rt        d«      ‚t        |d«       t        |d«       | j                  › d�}d|i}|r||d<   |r||d<   n|r||d	<   |r||d
<   |r||d<   |�||d<   |�||d<   |	�|	|d<   |
�|
|d<   |�||d<   |�t        ||«       ||d<   |�||d<   |�t	        |«      |d<   |�t        |«      |d<   |r|dz   nd}	 | j                  j                  |||| j                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       | d¬«      }|j                  r#|j                  | j                  |j                  <   t!        |j                  «       |S 7 Œ€# t"        j$                  $ r}t'        |«       ‚ d}~ww xY w­w)a¯  Create a new Sandbox.

        The sandbox is NOT automatically deleted. Use delete_sandbox() for cleanup,
        or use sandbox() for automatic cleanup with a context manager.

        Args:
            snapshot_id: Optional snapshot ID to boot from. Mutually exclusive
                with ``snapshot`` and ``snapshot_name``.
            snapshot: Snapshot to boot from, as a UUID, ``name:tag``, or a bare
                ``name`` (which means ``name:latest``). Prefer this over
                ``snapshot_id`` and ``snapshot_name``: it covers all three forms.
            snapshot_name: Deprecated synonym for ``snapshot``, kept for callers
                that predate it.
            name: Optional sandbox name (auto-generated if not provided).
            timeout: Timeout in seconds when waiting for ready (only used when
                wait_for_ready=True).
            wait_for_ready: If True (default), block until sandbox is ready.
                If False, return immediately with status "provisioning". Use
                get_sandbox_status() or wait_for_sandbox() to poll for readiness.
            idle_ttl_seconds: Idle timeout in seconds. The launcher
                automatically stops the sandbox after this duration of
                inactivity. Must be a multiple of 60. ``0`` explicitly
                disables the idle stop. When omitted (``None``), the server
                applies a default of ``600`` seconds (10 minutes).
            delete_after_stop_seconds: Seconds after the sandbox enters the
                ``stopped`` state before it (and its filesystem clone) are
                permanently deleted. Must be a multiple of 60. ``0`` disables
                stop-anchored deletion (manual cleanup required). When
                omitted (``None``), the server applies its configured default.
            vcpus: Number of vCPUs.
            mem_bytes: Memory in bytes.
            fs_capacity_bytes: Root filesystem capacity in bytes.
            mount_config: Mount configuration forwarded to the server as
                ``mount_config``. The backend expands mount auth into runtime
                proxy rules. Explicit AWS/GCP proxy rules in ``proxy_config``
                conflict with mount auth for the same provider.
            proxy_config: Per-sandbox proxy configuration forwarded to the
                server as-is. Shape matches the backend `proxy_config` field:
                ``{"rules": [...], "access_control":
                {"allow_list": [...]}}`` or ``{"access_control":
                {"deny_list": [...]}}``. Use ``access_control.allow_list`` to
                restrict outbound HTTPS to a set of host patterns (exact
                domains, globs like ``*.example.com``, IPs, CIDRs, or
                ``~regex``). Use ``proxy_config`` with provider rule helpers
                such as ``aws_auth`` to let the proxy sign supported
                AWS HTTPS requests on the sandbox's behalf.

            access_delegation: Optional grant letting code inside the sandbox
                call the LangSmith API as you, with no API key of its own.
                ``{"mode": "INHERIT"}`` grants everything you can do;
                ``{"mode": "EXPLICIT", "permissions": [...]}`` grants only the
                permissions listed, each of which you must already hold. The
                grant belongs to the sandbox, so anyone who can exec into it
                can make calls under it. Omit for no access.

        Returns:
            Created AsyncSandbox. When wait_for_ready=False, the sandbox will have
            status="provisioning" and cannot be used for operations until ready.

        Raises:
            ResourceTimeoutError: If timeout waiting for sandbox to be ready.
            ResourceCreationError: If sandbox creation fails.
            SandboxClientError: For other errors.
            ValueError: If TTL values are invalid, or if both ``snapshot_id`` and
                ``snapshot_name`` are provided.
        z,snapshot and snapshot_name must not disagreez@At most one of snapshot_id, snapshot or snapshot_name may be setr—   r˜   ú/boxesr¥   r¢   r•   r–   rF   rb   Nr™   rš   r›   rœ   r�   rž   r¦   r“   )ÚjsonrF   rI   F©ÚclientÚauto_delete)ra   r#   rN   r/   r-   r   rV   Úpostrx   Úraise_for_statusr   Ú	from_dictr©   ÚidrR   rb   r1   r   ÚHTTPStatusErrorr   )rX   r¢   r•   r–   rb   rF   r¥   r—   r˜   r™   rš   r›   rœ   r�   rž   r¦   rI   Ú	referenceÚurlÚpayloadÚhttp_timeoutÚresponser¤   Úes                           r:   r    z!AsyncSandboxClient.create_sandbox  s1  è ø€ ðl Ò- ˆ	Ù™¨(°mÒ*CÜÐKÓLÐLÙ™9ÜØRóð ô 	Ð%Ð'9Ô:ÜÐ.Ð0KÔLà—‘Ð  Ð'ˆð ˜nð#
ˆñ Ø%0ˆG�MÑ"ÙØ"*ˆG�JÒÙØ'4ˆG�OÑ$ÙØ!(ˆG�IÑÙØ"ˆG�F‰OØÐ'Ø*:ˆGÐ&Ñ'Ø$Ð0Ø3LˆGÐ/Ñ0ØÐØ$ˆG�GÑØÐ Ø#,ˆG�KÑ ØÐ(Ø+<ˆGÐ'Ñ(ØÐ#Ü.¨|¸\ÔJØ&2ˆG�NÑ#ØÐ#Ø&2ˆG�NÑ#ØÐ!Ü$7¸
Ó$CˆG�LÑ!ØÐ(Ü+FØ!ó,ˆGÐ'Ñ(ñ *8˜ "š¸Rˆð	Ø!ŸZ™ZŸ_™_ØØØ$Ø×-Ñ-¨gÓ6ð	 -ó ÷ ˆHð ×%Ñ%Ô'Ü"×,Ñ,Ø—‘“¨¸%ôˆGð �zŠzØ29·*±*�×!Ñ! '§,¡,Ñ/Ü  §¡Ô,ØˆNðùô ×$Ñ$ò 	Ü)¨!Ô,Øûð	üs=   ‚CF=Ã"1F ÄFÄA?F ÆF=ÆF ÆF:Æ)F5Æ5F:Æ:F=©rI   c             ƒ  ób  K  — | j                  |«       t        | j                  |«      }	 | j                  j	                  || j                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       | d¬«      }|j                  r#|j                  | j                  |j                  <   t        |j                  «       |S 7 Œ€# t        j                  $ r<}|j                   j"                  dk(  rt%        d|› d�d¬	«      |‚t'        |«       ‚ d}~ww xY w­w)
aK  Get a Sandbox by name.

        The sandbox is NOT automatically deleted. Use delete_sandbox() for cleanup.

        Args:
            name: Sandbox name.

        Returns:
            AsyncSandbox.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            SandboxClientError: For other errors.
        r¸   NFrª   é”  ú	Sandbox 'ú' not foundr¤   ©Úresource_type)rd   r   rN   rV   r]   rx   r®   r   r¯   r©   r°   rR   rb   r1   r   r±   r¶   Ústatus_coder   r   )rX   rb   rI   r³   r¶   r¤   r·   s          r:   Úget_sandboxzAsyncSandboxClient.get_sandbox  s  è ø€ ð" 	×Ñ˜DÔ!Ü�t—~‘~ tÓ,ˆð	Ø!ŸZ™ZŸ^™^¨C¸×9NÑ9NÈwÓ9W˜^ÓX×XˆHØ×%Ñ%Ô'Ü"×,Ñ,Ø—‘“¨¸%ôˆGð �zŠzØ29·*±*�×!Ñ! '§,¡,Ñ/Ü  §¡Ô,ØˆNð Yùô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % QÔ'Øûð	üs;   ‚(D/«/C ÁCÁA?C ÃD/ÃC ÃD,Ã07D'Ä'D,Ä,D/c             ƒ  óì  K  — | j                   › d�}	 | j                  j                  || j                  |«      ¬«      ƒ d{  –—† }|j	                  «        |j                  «       }|j                  dg «      D �cg c]  }t        j                  || d¬«      ‘Œ c}S 7 ŒZc c}w # t        j                  $ r:}|j                  j                  dk(  rt        d|› d	�«      |‚t        |«       ‚ d}~ww xY w­w)
zRList all Sandboxes.

        Returns:
            List of AsyncSandboxes.
        r¨   r¸   Nrs   Frª   rº   úAPI endpoint not found: ú%. Check that api_endpoint is correct.)rN   rV   r]   rx   r®   r©   r   r¯   r   r±   r¶   r¿   r   r   )rX   rI   r³   r¶   ÚdataÚcr·   s          r:   Úlist_sandboxesz!AsyncSandboxClient.list_sandboxes?  sù   è ø€ ð —‘Ð  Ð'ˆð	Ø!ŸZ™ZŸ^™^¨C¸×9NÑ9NÈwÓ9W˜^ÓX×XˆHØ×%Ñ%Ô'Ø—=‘=“?ˆDð Ÿ™ +¨rÔ2óá2�Aô ×&Ñ& q°À5ÖIØ2ñð ð Yúòøô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü%Ø.¨s¨eð 4:ð ;óð ðô % QÔ'Øûð	üsL   ‚C4“/B$ ÁBÁ8B$ Á;BÂB$ ÂC4ÂB$ ÂB$ Â$C1Â75C,Ã,C1Ã1C4)Únew_namer—   r˜   r�   rž   rI   c             ƒ  ó„  K  — t        |d«       t        |d«       | j                  |«       t        | j                  |«      }i }	|�||	d<   |�||	d<   |�||	d<   |�||	d<   |�t	        |«      |	d<   	 | j
                  j                  ||	| j                  |«      ¬«      ƒ d{  –—† }
|
j                  «        | j                  |«       t        j                  |
j                  «       | d¬	«      }|j                  r#|j                  | j                  |j                  <   t!        |j                  «       |S 7 Œ‘# t"        j$                  $ ru}|j&                  j(                  d
k(  rt+        d|› d�d¬«      |‚|j&                  j(                  dk(  rt-        d|› d�d¬«      |‚|�t/        ||«       t1        |«       ‚ d}~ww xY w­w)aé  Update a sandbox's properties.

        Args:
            name: Current sandbox name.
            new_name: New display name.
            idle_ttl_seconds: Idle timeout in seconds. Must be a multiple of
                60. ``0`` disables idle-stop. ``None`` leaves the existing
                value unchanged.
            delete_after_stop_seconds: Seconds after entering ``stopped``
                before deletion. Must be a multiple of 60. ``0`` disables
                stop-anchored deletion. ``None`` leaves the existing value
                unchanged.
            proxy_config: Replacement proxy configuration, forwarded to the
                server as-is (same shape as ``create_sandbox``). Rules replace
                the existing set rather than merging into it, so include every
                rule the sandbox should keep. Opaque header values carry over
                from the current config, so rotating one credential does not
                mean re-supplying secrets that can no longer be read. The
                sandbox must be ``ready``; start a stopped one first.

        Returns:
            Updated AsyncSandbox.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            ResourceNameConflictError: If new_name is already in use.
            SandboxNotReadyError: If ``proxy_config`` was given and the sandbox
                is not ``ready``.
            SandboxClientError: For other errors.
            ValueError: If TTL values are invalid.
        r—   r˜   Nrb   r�   rž   ©r©   rI   Frª   rº   r»   r¼   r¤   r½   i™  zSandbox name 'z' already in use)r#   rd   r   rN   r-   rV   Úpatchrx   r®   rj   r   r¯   r©   r°   rR   rb   r1   r   r±   r¶   r¿   r   r   r!   r   )rX   rb   rÇ   r—   r˜   r�   rž   rI   r³   r´   r¶   r¤   r·   s                r:   Úupdate_sandboxz!AsyncSandboxClient.update_sandboxZ  sÙ  è ø€ ôT 	Ð%Ð'9Ô:ÜÐ.Ð0KÔLà×Ñ˜DÔ!Ü�t—~‘~ tÓ,ˆØ"$ˆØÐØ&ˆG�F‰OØÐ'Ø*:ˆGÐ&Ñ'Ø$Ð0Ø3LˆGÐ/Ñ0ØÐ#Ø&2ˆG�NÑ#ØÐ!Ü$7¸
Ó$CˆG�LÑ!ð	Ø!ŸZ™Z×-Ñ-Ø˜'¨4×+@Ñ+@ÀÓ+Ið .ó ÷ ˆHð ×%Ñ%Ô'Ø× Ñ  Ô&Ü"×,Ñ,Ø—‘“¨¸%ôˆGð �zŠzØ29·*±*�×!Ñ! '§,¡,Ñ/Ü  §¡Ô,ØˆNðùô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðð �z‰z×%Ñ%¨Ò,Ü/Ø$ X JÐ.>Ð?Ø"+ôð ðð Ð'Ü" 1 dÔ+Ü$ QÔ'Øûð	üs>   ‚A.G Á10D5 Â!D3Â"BD5 Ä2G Ä3D5 Ä5F=ÅA0F8Æ8F=Æ=G c             ƒ  ó¶  K  — | j                  |«       t        | j                  |«      }	 | j                  j	                  || j                  |«      ¬«      ƒ d{  –—† }|j                  «        | j                  |«       y7 Œ&# t        j                  $ r@}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       Y d}~yd}~ww xY w­w)zÅDelete a Sandbox.

        Args:
            name: Sandbox name.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            SandboxClientError: For other errors.
        r¸   Nrº   r»   r¼   r¤   r½   )rd   r   rN   rV   Údeleterx   r®   rj   r   r±   r¶   r¿   r   r   ©rX   rb   rI   r³   r¶   r·   s         r:   Údelete_sandboxz!AsyncSandboxClient.delete_sandbox±  sÎ   è ø€ ð 	×Ñ˜DÔ!Ü�t—~‘~ tÓ,ˆð	(Ø!ŸZ™Z×.Ñ.Ø˜T×2Ñ2°7Ó;ð /ó ÷ ˆHð ×%Ñ%Ô'Ø× Ñ  Õ&ð	ùô
 ×$Ñ$ò 	(Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % Q×'Ñ'ûð	(üs@   ‚(C«/B ÁBÁ%B Â CÂB ÂCÂ6CÃCÃCÃCc             ƒ  óÒ  K  — | j                  |«       t        | j                  |d«      }	 | j                  j	                  || j                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       «      S 7 Œ7# t        j                  $ r<}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       ‚ d}~ww xY w­w)	aà  Get the provisioning status of a sandbox.

        This is a lightweight endpoint designed for high-frequency polling
        during sandbox provisioning. It returns only the status fields
        without full sandbox data.

        Args:
            name: Sandbox name.

        Returns:
            ResourceStatus with status and status_message.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            SandboxClientError: For other errors.
        Ústatusr¸   Nrº   r»   r¼   r¤   r½   )rd   r   rN   rV   r]   rx   r®   r'   r¯   r©   r   r±   r¶   r¿   r   r   rÎ   s         r:   Úget_sandbox_statusz%AsyncSandboxClient.get_sandbox_statusÍ  sÎ   è ø€ ð& 	×Ñ˜DÔ!Ü�t—~‘~ t¨XÓ6ˆð
	Ø!ŸZ™ZŸ^™^¨C¸×9NÑ9NÈwÓ9W˜^ÓX×XˆHØ×%Ñ%Ô'Ü!×+Ñ+¨H¯M©M«OÓ<Ð<ð Yùô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % QÔ'Øûð	üs:   ‚)C'¬/B ÁBÁ6B ÂC'ÂB ÂC$Â(7CÃC$Ã$C'iX  )Úexpires_in_secondsÚaccessrI   c             ƒ  ó   K  — y ­wrf   r?   ©rX   rb   ÚportrÓ   rÔ   rI   s         r:   ÚservicezAsyncSandboxClient.serviceï  ó   è ø€ ð ùó   ‚©rÓ   rI   c             ƒ  ó   K  — y ­wrf   r?   rÖ   s         r:   rØ   zAsyncSandboxClient.serviceú  rÙ   rÚ   c             ƒ  óÜ  ‡ ‡‡‡‡K  — t        ‰‰«       |�|dvrt        d|›�«      ‚|du}‰ j                  ‰«       t        ‰ j                  ‰d«      }d‰i}|s‰|d<   |�||d<   dˆˆˆˆˆ fd„}		 ‰ j
                  j                  ||‰ j                  ‰«      ¬	«      ƒ d{  –—† }
|
j                  «        |r#t        j                  |
j                  «       «      S t        j                  |
j                  «       |	¬
«      }‰ j                  ‰«      |_        |S 7 Œv# t        j                  $ r<}|j                   j"                  dk(  rt%        d‰› d�d¬«      |‚t'        |«       ‚ d}~ww xY w­w)aŠ  Get an authenticated URL for a service running inside a sandbox.

        Returns an :class:`AsyncServiceURL` whose async accessors
        auto-refresh the token transparently before it expires.  The
        object also provides async HTTP helper methods (``.get``,
        ``.post``, etc.) that inject the authentication header
        automatically.

        Args:
            name: Sandbox name.
            port: Port the service is listening on inside the sandbox.
            expires_in_seconds: Token TTL in seconds (1--86400, default 600).
            access: Gate the URL behind LangSmith login instead of a token,
                returning a :class:`ServiceLoginURL`. ``"restricted"`` admits
                anyone with ``sandboxes:read`` on the sandbox, ``"workspace"``
                any member of the owning workspace. Neither carries a token or
                expires, so ``expires_in_seconds`` does not apply. Omit for
                token mode; a login grant is durable, so token mode is refused
                with 409 while one is in place.
            headers: Optional per-request header overrides.

        Returns:
            AsyncServiceURL with auto-refreshing token and HTTP helpers.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            ValueError: If port or expires_in_seconds is out of range.
            SandboxClientError: For other errors.
        N)Ú
restrictedÚ	workspacez0access must be "restricted" or "workspace", got zservice-urlr×   rÓ   rÔ   c               “  óJ   •K  — ‰j                  ‰‰‰ ‰¬«      ƒ d {  –—† S 7 Œ­w)NrÛ   )rØ   )rÓ   rI   rb   r×   rX   s   €€€€€r:   Ú
_refresherz.AsyncSandboxClient.service.<locals>._refresher9  s3   øè ø€ ØŸ™ØØØ#5Øð	 &ó ÷ ð ð ús   ƒ#œ!�#rÉ   )rá   rº   r»   r¼   r¤   r½   )Úreturnr$   )r"   ra   rd   r   rN   rV   r­   rx   r®   r*   r¯   r©   r$   Ú_sandbox_idr   r±   r¶   r¿   r   r   )rX   rb   r×   rÓ   rÔ   rI   Ú
login_moder³   r´   rá   r¶   rØ   r·   s   ```` `       r:   rØ   zAsyncSandboxClient.service  s{  üè ø€ ôL 	  Ð&8Ô9ØÐ &Ð0KÑ"KÜØBÀ6À*ÐMóð ð  4Ð'ˆ
Ø×Ñ˜DÔ!Ü�t—~‘~ t¨]Ó;ˆØ#)¨4 .ˆÙØ,>ˆGÐ(Ñ)ØÐØ &ˆG�HÑ÷	ñ 	ð	Ø!ŸZ™ZŸ_™_Ø˜'¨4×+@Ñ+@ÀÓ+Ið -ó ÷ ˆHð ×%Ñ%Ô'ÙÜ&×0Ñ0°·±³ÓAÐAÜ%×/Ñ/°·±³ÈJÔWˆGØ"&×"5Ñ"5°dÓ";ˆGÔØˆNðùô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % QÔ'Øûð	üsH   ‡A)E,Á10D Â!DÂ"8D ÃE,Ã<D ÄE,ÄD ÄE)Ä-7E$Å$E)Å)E,)rÓ   Úcontent_typeÚcontent_dispositionrI   c             ƒ  ó2  K  — |�|dk  rt        d|› d�«      ‚| j                  |«       t        | j                  |d«      }d|i}|�||d<   |�||d<   |�||d	<   	 | j                  j                  ||| j                  |«      ¬
«      ƒ d{  –—† }	|	j                  «        t        j                  |	j                  «       «      S 7 Œ7# t        j                  $ r<}
|
j                  j                  dk(  rt        d|› d�d¬«      |
‚t!        |
«       ‚ d}
~
ww xY w­w)aM  Create a link that downloads one file from a sandbox.

        The link carries its own token, so anyone holding the URL can fetch
        that one file without a LangSmith credential. It is pinned to the
        sandbox and the exact path and cannot be repointed at another file.
        Fetching wakes a stopped sandbox.

        Do not modify the file after minting a link for it. The link is
        pinned to a path, not to a snapshot of the contents, so a later
        write to that path may or may not be reflected in what the link
        serves. Write a new file and mint a new link when the contents
        change.

        Args:
            name: Sandbox name.
            path: File path inside the sandbox.
            expires_in_seconds: Link TTL in seconds. Omit for a link that
                never expires.
            content_type: Content-Type to serve the file as.
            content_disposition: Content-Disposition to serve the file with,
                either ``"attachment"`` or ``"inline"``.
            headers: Optional per-request header overrides.

        Returns:
            DownloadURL with the link and its expiry, if any.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            ValueError: If expires_in_seconds is not positive.
            SandboxClientError: For other errors.
        Né   z/expires_in_seconds must be greater than 0 (got z(); omit it for a link that never expireszdownload-urlÚpathrÓ   rå   ræ   rÉ   rº   r»   r¼   r¤   r½   )ra   rd   r   rN   rV   r­   rx   r®   r&   r¯   r©   r   r±   r¶   r¿   r   r   )rX   rb   ré   rÓ   rå   ræ   rI   r³   r´   r¶   r·   s              r:   Úgenerate_download_urlz(AsyncSandboxClient.generate_download_urlS  sF  è ø€ ðR Ð)Ð.@À1Ò.DÜðØ*Ð+Ð+SðUóð ð 	×Ñ˜DÔ!Ü�t—~‘~ t¨^Ó<ˆØ#)¨4 .ˆØÐ)Ø,>ˆGÐ(Ñ)ØÐ#Ø&2ˆG�NÑ#ØÐ*Ø-@ˆGÐ)Ñ*ð	Ø!ŸZ™ZŸ_™_Ø˜'¨4×+@Ñ+@ÀÓ+Ið -ó ÷ ˆHð ×%Ñ%Ô'Ü×(Ñ(¨¯©«Ó9Ð9ð	ùô
 ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % QÔ'Øûð	üs<   ‚ADÁ0C ÂCÂ6C ÃDÃC ÃDÃ7DÄDÄDéx   g      ð?)rF   Úpoll_intervalrI   c             ƒ  óâ  K  — ddl }|j                  «       |z   }	 | j                  ||¬«      ƒ d{  –—† }|j                  dk(  r| j	                  ||¬«      ƒ d{  –—† S |j                  dk(  rt        |j                  xs dd¬«      ‚||j                  «       z
  }|dk  rt        d	|› d
|› d�d|j                  ¬«      ‚t        j                  t        ||«      «      ƒ d{  –—†  ŒÎ7 Œ·7 Œ�7 Œ	­w)a¬  Poll until a sandbox reaches "ready" or "failed" status.

        Uses the lightweight status endpoint for polling, then fetches the
        full sandbox data once ready.

        Args:
            name: Sandbox name.
            timeout: Maximum time to wait in seconds.
            poll_interval: Time between status checks in seconds.

        Returns:
            AsyncSandbox in "ready" status.

        Raises:
            ResourceCreationError: If sandbox status becomes "failed".
            ResourceTimeoutError: If timeout expires while still "provisioning".
            ResourceNotFoundError: If sandbox not found.
            SandboxClientError: For other errors.
        r   Nr¸   ÚreadyÚfailedzSandbox provisioning failedr¤   r½   r»   ú' not ready after Ús©r¾   Úlast_status)ÚtimeÚ	monotonicrÒ   rÑ   rÀ   r   Ústatus_messager   r‚   ÚsleepÚmin)	rX   rb   rF   rì   rI   rô   ÚdeadlinerÑ   Ú	remainings	            r:   Úwait_for_sandboxz#AsyncSandboxClient.wait_for_sandbox™  sø   è ø€ ó6 	à—>‘>Ó# gÑ-ˆØØ×2Ñ2°4ÀÐ2ÓI×IˆFØ�}‰} Ò'Ø!×-Ñ-¨d¸GÐ-ÓD×DÐDØ�}‰} Ò(Ü+Ø×)Ñ)ÒJÐ-JØ"+ôð ð ! 4§>¡>Ó#3Ñ3ˆIØ˜AŠ~Ü*Ø ˜vÐ%7¸°yÀÐBØ"+Ø &§¡ôð ô
 —-‘-¤ M°9Ó =Ó>×>Ð>ð! ØIøàDøð ?ús4   ‚/C/±C)²)C/ÁC+ÁBC/Ã#C-Ã$C/Ã+C/Ã-C/©rF   rI   c             ƒ  óÒ  K  — | j                  |«       t        | j                  |d«      }	 | j                  j	                  |i | j                  |«      ¬«      ƒ d{  –—† }|j                  «        | j                  |||¬	«      ƒ d{  –—† S 7 Œ0# t        j                  $ r@}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       Y d}~Œld}~ww xY w7 Œ\­w)
aõ  Start a stopped sandbox and wait until ready.

        Args:
            name: Sandbox name.
            timeout: Timeout in seconds when waiting for ready.

        Returns:
            AsyncSandbox in "ready" status.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            ResourceCreationError: If sandbox fails during startup.
            ResourceTimeoutError: If sandbox doesn't become ready within timeout.
            SandboxClientError: For other errors.
        ÚstartrÉ   Nrº   r»   r¼   r¤   r½   rü   )rd   r   rN   rV   r­   rx   r®   r   r±   r¶   r¿   r   r   rû   )rX   rb   rF   rI   r³   r¶   r·   s          r:   Ústart_sandboxz AsyncSandboxClient.start_sandboxÉ  sæ   è ø€ ð, 	×Ñ˜DÔ!Ü�t—~‘~ t¨WÓ5ˆð
	(Ø!ŸZ™ZŸ_™_Ø˜" d×&;Ñ&;¸GÓ&Dð -ó ÷ ˆHð ×%Ñ%Ô'ð ×*Ñ*¨4¸È'Ð*ÓR×RÐRðùô ×$Ñ$ò 	(Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % Q×'Ñ'ûð	(úð SúsL   ‚)C'¬0B ÁBÁB Á1C'ÂC%Â	C'ÂB ÂC"Â"6CÃC'ÃC"Ã"C'c             ƒ  ó˜  K  — | j                  |«       t        | j                  |d«      }	 | j                  j	                  |i | j                  |«      ¬«      ƒ d{  –—† }|j                  «        y7 Œ# t        j                  $ r@}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       Y d}~yd}~ww xY w­w)	z÷Stop a running sandbox (preserves sandbox files for later restart).

        Args:
            name: Sandbox name.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            SandboxClientError: For other errors.
        ÚstoprÉ   Nrº   r»   r¼   r¤   r½   )rd   r   rN   rV   r­   rx   r®   r   r±   r¶   r¿   r   r   rÎ   s         r:   Ústop_sandboxzAsyncSandboxClient.stop_sandboxð  sÂ   è ø€ ð 	×Ñ˜DÔ!Ü�t—~‘~ t¨VÓ4ˆð
	(Ø!ŸZ™ZŸ_™_Ø˜" d×&;Ñ&;¸GÓ&Dð -ó ÷ ˆHð ×%Ñ%Õ'ðùô ×$Ñ$ò 	(Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜v [Ð1Àôàðô % Q×'Ñ'ûð	(üs@   ‚)C
¬0A4 ÁA2ÁA4 Á1C
Á2A4 Á4CÂ6CÂ=C
ÃCÃC
é<   )ÚtagÚregistry_idrž   rF   rI   c             ƒ  óä  K  — | j                   › d�}	|||dœ}
|�||
d<   |�||
d<   |�t        |«      |
d<   	 | j                  j                  |	|
| j	                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       «      }| j                  |j                  ||¬«      ƒ d{  –—† S 7 Œ]# t        j                  $ r}t        |«       ‚ d}~ww xY w7 Œ-­w)	a¬  Build a snapshot from a Docker image.

        Blocks until the snapshot is ready (polls with 2s interval).

        Args:
            name: Snapshot name.
            docker_image: Docker image to build from (e.g., "python:3.12-slim").
            fs_capacity_bytes: Filesystem capacity in bytes.
            registry_id: Private registry ID.
            timeout: Timeout in seconds when waiting for ready.

        Returns:
            Snapshot in "ready" status.

        Raises:
            ResourceTimeoutError: If snapshot doesn't become ready within timeout.
            ResourceCreationError: If snapshot build fails.
            SandboxClientError: For other errors.
        ú
/snapshots)rb   Údocker_imager›   Nr  r  rž   rÉ   rü   )rN   r-   rV   r­   rx   r®   r+   r¯   r©   r   r±   r   Úwait_for_snapshotr°   )rX   rb   r  r›   r  r  rž   rF   rI   r³   r´   r¶   r•   r·   s                 r:   Úcreate_snapshotz"AsyncSandboxClient.create_snapshot  s  è ø€ ð> —‘Ð  
Ð+ˆð Ø(Ø!2ñ#
ˆð
 ˆ?Ø ˆG�E‰NØÐ"Ø%0ˆG�MÑ"ØÐ!Ü$7¸
Ó$CˆG�LÑ!ð	Ø!ŸZ™ZŸ_™_Ø˜'¨4×+@Ñ+@ÀÓ+Ið -ó ÷ ˆHð ×%Ñ%Ô'Ü×)Ñ)¨(¯-©-«/Ó:ˆHð
 ×+Ñ+Ø�K‰K °'ð ,ó 
÷ 
ð 	
ðùô
 ×$Ñ$ò 	Ü$ QÔ'Øûð	úð
úsF   ‚4C0·0C Á'CÁ(7C Â!C0Ã C.ÃC0ÃC ÃC+ÃC&Ã&C+Ã+C0Ú.)ÚcontextÚ
build_argsÚtargetÚon_build_logr™   rš   rF   rI   c             ƒ  ó(  K  — t        ||«      \  }}dt        j                  «       j                  dd › �}dt        j                  «       j                  dd › �}t	        j
                  |d«      }t	        j
                  |d«      }dt        j                  «       j                  › �}t	        j
                  |d«      }t	        j
                  |d	«      }| j                  ||
||	||¬
«      ƒ d{  –—† 4 ƒd{  –—† }|j                  |t        j                  t        |«      ƒ d{  –—† |
|¬«      ƒ d{  –—†  |j                  d|z   dz   |z   dz   |z   dz   |z   |
|¬«      ƒ d{  –—†  |j                  t        |||||||¬«      |
|||¬«      ƒ d{  –—† }|j                  dk7  rt        dd¬«      ‚| j                  |j                   ||||
|¬«      ƒ d{  –—† cddd«      ƒd{  –—†  S 7 Œÿ7 Œø7 ŒÌ7 Œ¿7 Œ�7 Œd7 Œ!7 Œ# 1 ƒd{  –—†7  sw Y   yxY w­w)a¸  Build a snapshot from a local Dockerfile context.

        When ``fs_capacity_bytes`` is omitted, the server applies its default.
        ``vcpus`` and ``mem_bytes`` size the temporary builder sandbox. The
        build runs BuildKit plus the native snapshotter's layer copies inside
        it, which contend for a single core by default, so giving the builder
        an extra vCPU can cut a cold build's wall time substantially.
        zsnapshot-builder-Né   z/var/lib/langsmith-build/r  zcontext.tarzlangsmith-snapshot-build:zbuildkit-rootzbuildkit-run)rb   rF   r™   rš   r›   rI   rü   zrm -rf z && mkdir -p z && tar -xf z -C )Úremote_contextÚdockerfile_relÚ	image_refÚbuildkit_rootÚbuildkit_runr  r  )rF   Ú	on_stdoutÚ	on_stderrrI   r   z Dockerfile snapshot build failedr•   r½   )r  r›   rF   rI   )r   r_   Úuuid4ÚhexÚ	posixpathÚjoinr¤   Úwriter‚   Ú	to_threadr   Úrunr   Ú	exit_coder   Úcapture_snapshotrb   )rX   rb   Ú
dockerfiler›   r  r  r  r  r™   rš   rF   rI   Úcontext_pathr  Úbuilder_nameÚ
build_rootr  Ú
remote_tarr  r  r  r¤   Úresults                          r:   Úcreate_snapshot_from_dockerfilez2AsyncSandboxClient.create_snapshot_from_dockerfileH  sr  è ø€ ô. (CÀ:ÈwÓ'WÑ$ˆ�nà*¬4¯:©:«<×+;Ñ+;¸C¸RÐ+@Ð*AÐBˆð 1´·±³×1AÑ1AÀ#À2Ð1FÐ0GÐHˆ
Ü"Ÿ™¨
°IÓ>ˆÜ—^‘^ J°Ó>ˆ
Ø/´·
±
³×0@Ñ0@Ð/AÐBˆ	Ü!Ÿ™ z°?ÓCˆÜ —~‘~ j°.ÓAˆàŸ™ØØØØØ/Øð &ó 
÷ 
÷ 
ð 
ð Ø—-‘-ØÜ×'Ñ'Ô(@À,ÓO×OØØð	  ó ÷ ð ð —+‘+ØØ ñ!à!ñ"ð !ñ!ð !ñ	!ð
 ñð ñð !ñ!ð  Øð ó ÷ ð ð #Ÿ;™;Ü.Ø#1Ø#1Ø'Ø"/Ø!-Ø)Ø!ôð  Ø&Ø&Øð 'ó ÷ ˆFð ×Ñ 1Ò$Ü+Ø6Ø",ôð ð ×.Ñ.Ø—‘ØØ&Ø"3ØØð /ó ÷ ÷_
÷ 
ò 
øð 
øð Pøðøðøðøð(øð_
ø÷ 
÷ 
ñ 
üsµ   ‚C+HÃ-G-Ã.HÃ6G/Ã7HÃ:*G=Ä$G1Ä%G=Ä3G3Ä40G=Å$G5Å%-G=ÆG7ÆAG=ÇG9ÇG=ÇHÇ'G;Ç(HÇ/HÇ1G=Ç3G=Ç5G=Ç7G=Ç9G=Ç;HÇ=HÈHÈHÈH)r  r  r›   rž   rF   rI   c             ƒ  óv  K  — | j                  |«       t        | j                  |d«      }	d|i}
|�||
d<   |�||
d<   |�||
d<   |�t        |«      |
d<   	 | j                  j                  |	|
| j                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       «      }| j#                  |j$                  ||¬«      ƒ d{  –—† S 7 Œ]# t        j                  $ r<}|j                  j                  d	k(  rt        d
|› d�d¬«      |‚t!        |«       ‚ d}~ww xY w7 ŒX­w)aQ  Capture a snapshot from a running sandbox.

        Blocks until the snapshot is ready (polls with 2s interval).

        Args:
            sandbox_name: Name of the sandbox to capture from.
            name: Snapshot name.
            tag: Tag to publish the snapshot under, within ``name``. Re-using a
                tag moves it to the new snapshot, leaving the previous one
                addressable by id. Defaults server-side to ``latest``.
            timeout: Timeout in seconds when waiting for ready.

        Returns:
            Snapshot in "ready" status.

        Raises:
            ResourceNotFoundError: If sandbox not found.
            ResourceTimeoutError: If snapshot doesn't become ready within timeout.
            ResourceCreationError: If snapshot capture fails.
            SandboxClientError: For other errors.
        r•   rb   Nr  r  r›   rž   rÉ   rº   r»   r¼   r¤   r½   rü   )rd   r   rN   r-   rV   r­   rx   r®   r+   r¯   r©   r   r±   r¶   r¿   r   r   r	  r°   )rX   Úsandbox_namerb   r  r  r›   rž   rF   rI   r³   r´   r¶   r•   r·   s                 r:   r!  z#AsyncSandboxClient.capture_snapshot¦  sV  è ø€ ðB 	×Ñ˜LÔ)Ü�t—~‘~ |°ZÓ@ˆà#)¨4 .ˆØˆ?Ø ˆG�E‰NØÐ#Ø&2ˆG�NÑ#ØÐ(Ø+<ˆGÐ'Ñ(ØÐ!Ü$7¸
Ó$CˆG�LÑ!ð	Ø!ŸZ™ZŸ_™_Ø˜'¨4×+@Ñ+@ÀÓ+Ið -ó ÷ ˆHð ×%Ñ%Ô'Ü×)Ñ)¨(¯-©-«/Ó:ˆHð ×+Ñ+Ø�K‰K °'ð ,ó 
÷ 
ð 	
ðùô
 ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø ˜~¨[Ð9Èôàðô % QÔ'Øûð	úð
úsH   ‚AD9Á0C% ÂC#Â7C% Â=!D9ÃD7ÃD9Ã#C% Ã%D4Ã87D/Ä/D4Ä4D9c             ƒ  ó¶  K  — | j                   › dt        |«      › �}	 | j                  j                  || j	                  |«      ¬«      ƒ d{  –—† }|j                  «        t        j                  |j                  «       «      S 7 Œ7# t        j                  $ r<}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       ‚ d}~ww xY w­w)	a¿  Get a snapshot by ID or by a Docker-style reference.

        Args:
            snapshot_id: Snapshot UUID, ``name:tag``, or a bare ``name``. A bare
                name means ``name:latest``, falling back to the newest ready
                untagged snapshot of that name.

        Returns:
            Snapshot.

        Raises:
            ResourceNotFoundError: If snapshot not found.
            SandboxClientError: For other errors.
        ú/snapshots/r¸   Nrº   ú
Snapshot 'r¼   r•   r½   )rN   r   rV   r]   rx   r®   r+   r¯   r©   r   r±   r¶   r¿   r   r   ©rX   r¢   rI   r³   r¶   r·   s         r:   Úget_snapshotzAsyncSandboxClient.get_snapshotæ  sÊ   è ø€ ð" —‘Ð  Ô,DÀ[Ó,QÐ+RÐSˆð
	Ø!ŸZ™ZŸ^™^¨C¸×9NÑ9NÈwÓ9W˜^ÓX×XˆHØ×%Ñ%Ô'Ü×%Ñ% h§m¡m£oÓ6Ð6ð Yùô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø   ¨[Ð9Èôàðô % QÔ'Øûð	üs:   ‚Cž/B ÁBÁ6B ÂCÂB ÂCÂ7CÃCÃCc             ƒ  ó  K  — | j                   › dt        |«      › �}	 | j                  j                  || j	                  |«      ¬«      ƒ d{  –—† }|j                  «        |j                  «       j                  d«      xs g D �cg c]  }t        j                  |«      ‘Œ c}S 7 ŒXc c}w # t        j                  $ r<}|j                  j                  dk(  rt        d|› d�d¬	«      |‚t        |«       ‚ d}~ww xY w­w)
aÄ  List every tag published under a snapshot name.

        Args:
            name: Snapshot name, without a tag.

        Returns:
            Each tag under the name with the snapshot it resolves to. Empty when
            the name exists but currently carries no tags.

        Raises:
            ResourceNotFoundError: If nobody has published under the name.
            SandboxClientError: For other errors, including a name carrying a tag.
        z/snapshots-by-name/r¸   NÚtagsrº   zSnapshot name 'r¼   r•   r½   )rN   r   rV   r]   rx   r®   r©   r,   r¯   r   r±   r¶   r¿   r   r   )rX   rb   rI   r³   r¶   r  r·   s          r:   Úlist_snapshot_tagsz%AsyncSandboxClient.list_snapshot_tags  sû   è ø€ ð  —‘Ð Ð 3Ô4GÈÓ4MÐ3NÐOˆð	Ø!ŸZ™ZŸ^™^¨C¸×9NÑ9NÈwÓ9W˜^ÓX×XˆHØ×%Ñ%Ô'à6>·m±m³o×6IÑ6IÈ&Ó6QÒ6WÐUWÐ6WóÙ6W¨s”×%Ñ% cÕ*Ð6Wñð ð Yúòøô ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü+Ø% d V¨;Ð7Àzôàðô % QÔ'Øûð	üsL   ‚C?ž/B- ÁB&Á9B- ÂB(Â#B- Â%C?Â&B- Â(B- Â-C<Ã 7C7Ã7C<Ã<C?)Úname_containsÚlimitÚoffsetrI   c             ƒ  ó  K  — | j                   › d�}i }|�||d<   |�||d<   |�||d<   	 | j                  j                  ||xs d| j                  |«      ¬«      ƒ d{  –—† }|j	                  «        |j                  «       }|j                  dg «      D �	cg c]  }	t        j                  |	«      ‘Œ c}	S 7 ŒWc c}	w # t        j                  $ r:}
|
j                  j                  dk(  rt        d	|› d
�«      |
‚t        |
«       ‚ d}
~
ww xY w­w)aV  List snapshots.

        The backend always paginates this endpoint. When ``limit`` is omitted
        the server applies a default page size (currently 50), so a single
        call is not guaranteed to return every snapshot. To iterate through
        all results, repeat the call with increasing ``offset`` values (or an
        explicit ``limit``) until fewer than ``limit`` snapshots come back.

        Args:
            name_contains: Optional case-insensitive substring filter applied
                to snapshot names server-side.
            limit: Optional maximum number of snapshots to return for a single
                request. Must be between 1 and 500 (inclusive); the server
                rejects values outside that range. Defaults to 50 server-side
                when omitted.
            offset: Optional number of snapshots to skip before returning
                results. Must be ``>= 0``. Useful for paginating through
                large result sets in combination with ``limit``.

        Returns:
            A single page of Snapshots matching the provided filters.
        r  Nr3  r4  r5  )ÚparamsrI   Ú	snapshotsrº   rÂ   rÃ   )rN   rV   r]   rx   r®   r©   r+   r¯   r   r±   r¶   r¿   r   r   )rX   r3  r4  r5  rI   r³   r7  r¶   rÄ   rñ   r·   s              r:   Úlist_snapshotsz!AsyncSandboxClient.list_snapshots%  s.  è ø€ ð< —‘Ð  
Ð+ˆà!#ˆØÐ$Ø&3ˆF�?Ñ#ØÐØ#ˆF�7‰OØÐØ%ˆF�8Ñð	Ø!ŸZ™ZŸ^™^ØØ’~ Ø×-Ñ-¨gÓ6ð ,ó ÷ ˆHð
 ×%Ñ%Ô'Ø—=‘=“?ˆDØ37·8±8¸KÈÔ3LÓMÑ3L¨a”H×&Ñ& qÕ)Ð3LÑMÐMðúò NøÜ×$Ñ$ò 	Ø�z‰z×%Ñ%¨Ò,Ü%Ø.¨s¨eð 4:ð ;óð ðô % QÔ'Øûð	üsL   ‚'Dª4B= ÁB6Á8B= ÂB8Â3B= Â5DÂ6B= Â8B= Â=D
Ã5DÄD
Ä
Dc             ƒ  óz  K  — | j                   › dt        |«      › �}	 | j                  j                  || j	                  |«      ¬«      ƒ d{  –—† }|j                  «        y7 Œ# t        j                  $ r@}|j                  j                  dk(  rt        d|› d�d¬«      |‚t        |«       Y d}~yd}~ww xY w­w)	zÏDelete a snapshot.

        Args:
            snapshot_id: Snapshot UUID.

        Raises:
            ResourceNotFoundError: If snapshot not found.
            SandboxClientError: For other errors.
        r,  r¸   Nrº   r-  r¼   r•   r½   )rN   r   rV   rÍ   rx   r®   r   r±   r¶   r¿   r   r   r.  s         r:   Údelete_snapshotz"AsyncSandboxClient.delete_snapshot_  s¾   è ø€ ð —‘Ð  Ô,?ÀÓ,LÐ+MÐNˆð
	(Ø!ŸZ™Z×.Ñ.Ø˜T×2Ñ2°7Ó;ð /ó ÷ ˆHð ×%Ñ%Õ'ðùô ×$Ñ$ò 	(Ø�z‰z×%Ñ%¨Ò,Ü+Ø   ¨[Ð9Èôàðô % Q×'Ñ'ûð	(üs@   ‚B;ž/A% ÁA#ÁA% Á"B;Á#A% Á%B8Á86B3Â.B;Â3B8Â8B;i,  g       @c             ƒ  ó¬  K  — ddl }|j                  «       |z   }	 | j                  ||¬«      ƒ d{  –—† }|j                  dk(  r|S |j                  dk(  rt	        |j
                  xs dd¬«      ‚||j                  «       z
  }|dk  rt        d	|› d
|› d�d|j                  ¬«      ‚t        j                  t        ||«      «      ƒ d{  –—†  Œµ7 Œž7 Œ­w)a&  Poll until a snapshot reaches "ready" or "failed" status.

        Args:
            snapshot_id: Snapshot UUID.
            timeout: Maximum time to wait in seconds.
            poll_interval: Time between status checks in seconds.

        Returns:
            Snapshot in "ready" status.

        Raises:
            ResourceCreationError: If snapshot status becomes "failed".
            ResourceTimeoutError: If timeout expires.
            ResourceNotFoundError: If snapshot not found.
            SandboxClientError: For other errors.
        r   Nr¸   rî   rï   zSnapshot build failedr•   r½   r-  rð   rñ   rò   )
rô   rõ   r/  rÑ   r   rö   r   r‚   r÷   rø   )	rX   r¢   rF   rì   rI   rô   rù   r•   rú   s	            r:   r	  z$AsyncSandboxClient.wait_for_snapshoty  sà   è ø€ ó0 	à—>‘>Ó# gÑ-ˆØØ!×.Ñ.¨{ÀGÐ.ÓL×LˆHØ�‰ 'Ò)Ø�Ø�‰ (Ò*Ü+Ø×+Ñ+ÒFÐ/FØ",ôð ð ! 4§>¡>Ó#3Ñ3ˆIØ˜AŠ~Ü*Ø   Ð-?À¸yÈÐJØ",Ø (§¡ôð ô
 —-‘-¤ M°9Ó =Ó>×>Ð>ð! ØLøð ?ús"   ‚/C±C²BCÃ
CÃCÃC)
rE   úOptional[str]rF   ÚfloatrG   r=  rH   ÚintrI   úOptional[Mapping[str, str]])rb   r^   râ   r=  )rb   r^   râ   ÚNone©râ   r^   )râ   r3   )rI   ÚRequestHeadersrâ   zOptional[dict[str, str]])râ   r   )râ   rA  )râ   rB   )rŒ   zOptional[type]r�   zOptional[BaseException]rŽ   zOptional[Any]râ   rA  rf   )r¢   r=  r•   r=  r–   r=  rb   r=  rF   r?  r—   úOptional[int]r˜   rD  r™   rD  rš   rD  r›   rD  rœ   úOptional[SandboxMountConfig]r�   úOptional[SandboxProxyConfig]rž   ú*Optional[Union[RunConfig, dict[str, Any]]]rI   rC  râ   r   )"r¢   r=  r•   r=  r–   r=  rb   r=  rF   r?  r¥   Úboolr—   rD  r˜   rD  r™   rD  rš   rD  r›   rD  rœ   rE  r�   rF  rž   rG  r¦   zOptional[AccessDelegation]rI   rC  râ   r   )rb   r^   rI   rC  râ   r   )rI   rC  râ   zlist[AsyncSandbox])rb   r^   rÇ   r=  r—   rD  r˜   rD  r�   rF  rž   rG  rI   rC  râ   r   )rb   r^   rI   rC  râ   rA  )rb   r^   rI   rC  râ   r'   )rb   r^   r×   r?  rÓ   r?  rÔ   rA  rI   rC  râ   r$   )rb   r^   r×   r?  rÓ   r?  rÔ   r)   rI   rC  râ   r*   )rb   r^   r×   r?  rÓ   r?  rÔ   zOptional[ServiceAccess]rI   rC  râ   z'Union[AsyncServiceURL, ServiceLoginURL])rb   r^   ré   r^   rÓ   rD  rå   r=  ræ   z$Optional[DownloadContentDisposition]rI   rC  râ   r&   )
rb   r^   rF   r?  rì   r>  rI   rC  râ   r   )rb   r^   rF   r?  rI   rC  râ   r   )rb   r^   r  r^   r›   r?  r  r=  r  r=  rž   rG  rF   r?  rI   rC  râ   r+   )rb   r^   r"  úUnion[str, os.PathLike[str]]r›   rD  r  rI  r  r@  r  r=  r  zOptional[Callable[[str], Any]]r™   rD  rš   rD  rF   r?  rI   rC  râ   r+   )r*  r^   rb   r^   r  r=  r  r=  r›   rD  rž   rG  rF   r?  rI   rC  râ   r+   )r¢   r^   rI   rC  râ   r+   )rb   r^   rI   rC  râ   zlist[SnapshotTag])
r3  r=  r4  rD  r5  rD  rI   rC  râ   zlist[Snapshot])r¢   r^   rI   rC  râ   rA  )
r¢   r^   rF   r?  rì   r>  rI   rC  râ   r+   )'Ú__name__Ú
__module__Ú__qualname__Ú__doc__r[   rd   rj   ro   Úpropertyrt   rx   rz   r|   r~   rˆ   rŠ   r�   r’   r¤   r    rÀ   rÆ   rË   rÏ   rÒ   r
   rØ   rê   rû   rÿ   r  r
  r(  r!  r/  r2  r9  r;  r	  r?   r<   r:   rB   rB   X   sû  „ ñð  '+ØØ!%ØØ/3ñ)Að $ð)Að ð	)Að
 ð)Að ð)Að -ó)AóV	ó
óð ò<ó ð<ó8:ó=ó
ó$2óó$ðà ðð )ðð ð	ð
 
óóAð &*ðbð #'Ø'+Ø"ØØ*.Ø37Ø#Ø#'Ø+/Ø59Ø59ØAEØ"&ñ!bà"ðbð  ð	bð
 %ðbð ðbð ðbð (ðbð $1ðbð ðbð !ðbð )ðbð 3ðbð 3ðbð ?ðbð   ð!bð" 
ó#bðL &*ðXð #'Ø'+Ø"ØØ#Ø*.Ø37Ø#Ø#'Ø+/Ø59Ø59ØAEØ8<Ø"&ñ%Xà"ðXð  ð	Xð
 %ðXð ðXð ðXð ðXð (ðXð $1ðXð ðXð !ðXð )ðXð 3ðXð 3ðXð  ?ð!Xð" 6ð#Xð$  ð%Xð& 
ó'Xðv 7;ñ$Øð$Ø%3ð$à	ó$ðN ,0ñØ(ðà	óð> #'Ø*.Ø37Ø59ØAEØ"&ñUàðUð  ð	Uð
 (ðUð $1ðUð 3ðUð ?ðUð  ðUð 
óUðp 7;ñ(Øð(Ø%3ð(à	ó(ð: 7;ñ Øð Ø%3ð à	ó ðD ð #&ØØ"&ñàðð ðð
  ðð ðð  ðð 
òó ðð ð #&à"&ñàðð ðð
  ðð ðð  ðð 
òó ðð #&Ø*.Ø"&ñLàðLð ðLð
  ðLð (ðLð  ðLð 
1óLðf -1Ø&*ØDHØ"&ñDàðDð ðDð
 *ðDð $ðDð BðDð  ðDð 
óDðT Ø"Ø"&ñ.?àð.?ð ð	.?ð
 ð.?ð  ð.?ð 
ó.?ðh Ø"&ñ%Sàð%Sð ð	%Sð
  ð%Sð 
ó%SðN JNõ (ðF "Ø%)ØAEØØ"&ñ9
àð9
ð ð9
ð ð	9
ð ð9
ð #ð9
ð ?ð9
ð ð9
ð  ð9
ð 
ó9
ð~ ,0ð	\ð 14Ø26Ø $Ø7;Ø#Ø#'ØØ"&ñ\àð\ð 1ð\ð )ð	\ð .ð\ð 0ð\ð ð\ð 5ð\ð ð\ð !ð\ð ð\ð  ð\ð 
ó\ðF "Ø&*Ø+/ØAEØØ"&ñ>
àð>
ð ð>
ð
 ð>
ð $ð>
ð )ð>
ð ?ð>
ð ð>
ð  ð>
ð 
ó>
ðB >BñØðØ,:ðà	óð@ 7;ñØðØ%3ðà	óðF (,Ø#Ø $Ø"&ñ8ð %ð8ð ð	8ð
 ð8ð  ð8ð 
ó8ðv >Bñ(Øð(Ø,:ð(à	ó(ð< Ø"Ø"&ñ+?àð+?ð ð	+?ð
 ð+?ð  ð+?ð 
ô+?r<   rB   rB  )râ   r=  )NrM  Ú
__future__r   r‚   Úosr  r_   Úcollections.abcr   r   Útypingr   r   r   r	   r
   Ú	langsmithr   r7   Úlangsmith._openapi_clientr   Ú langsmith._openapi_client._httpxr   Úlangsmith.clientr   Ú$langsmith.sandbox._access_delegationr   r   Ú langsmith.sandbox._async_sandboxr   Úlangsmith.sandbox._clientr   r   r   r   r   r   r   Úlangsmith.sandbox._exceptionsr   r   r   r   r   Úlangsmith.sandbox._helpersr   r   r    r!   r"   r#   Úlangsmith.sandbox._modelsr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   Úlangsmith.sandbox._mountsr.   r/   Úlangsmith.sandbox._proxy_configr0   Úlangsmith.sandbox._tracingr1   Úlangsmith.sandbox._transportr2   Ú8langsmith._openapi_client.resources.sandboxes.registriesr3   r;   r@   r^   rC  rB   r?   r<   r:   Ú<module>rb     s«   ðÙ Lå "ã Û 	Û Û ß -ß @Õ @å 'Ý 4Ý 2Ý 2÷õ :÷÷ ñ ÷õ ÷÷ ÷÷ ÷ ÷õ ?Ý ;Ý <áõó
=ó+ð
 ˜' # s (Ñ+Ñ,€÷L?ò L?r<   