4RjrZUdZddlmZddlZddlZddlZddlmZmZm Z ddl m Z ddl Z ddl mZdd lmZmZmZd d lmZmZmZdd lmZd d lmZmZddlmZmZmZerd dl m!Z!ddl"m#Z#d dl$m%Z%ddgZ&ejNe(Z)dZ*dZ+dZ,ee ee dge effZ-gee.Z/de0d<dd ddZ1ddZ2GddZ3y) uThe self-hosted environment worker — the full composition of the control-plane poller and the per-session tool runner. :class:`EnvironmentWorker` claims work items from a self-hosted environment, and for each claimed ``session`` work item: builds the per-session :class:`~anthropic.lib.tools.agent_toolset.AgentToolContext` and downloads the session agent's skills, then runs a :class:`~anthropic.lib.tools._beta_session_runner.SessionToolRunner` for the session *while* heartbeating the work-item lease in parallel; on exit it force-stops the work item and loops to the next one. The lease heartbeat reporting ``state == "stopping"`` (or a lost lease) ends the session run. Build one from the generated work resource:: client.beta.environments.work.worker(environment_id=..., environment_key=...) or construct it directly:: from anthropic.lib.environments import EnvironmentWorker EnvironmentWorker(client, environment_id=..., environment_key=...) :meth:`EnvironmentWorker.handle_item` runs that same per-work-item flow for a single work item you've already claimed (e.g. a ``worker poll --on-work`` script handed one to a fresh process); with no arguments it reads the ``ANTHROPIC_*`` env vars that command sets. ) annotationsN) TYPE_CHECKINGUnionCallable)Sequence)TRANSIENT_ERRORS) _is_status aiter_work _is_fatal_4xx)HeadersNotGiven not_given)_copy_client_with_bearer_auth)BetaSelfHostedWorkBetaSessionWorkData)DEFAULT_MAX_IDLEBetaAnyRunnableTool_run_session_tools)AsyncAnthropicAgentToolContext) AsyncWorkEnvironmentWorkerEnvironmentWorkerToolsg>@gV@ NO_HEARTBEATrztuple[type[Exception], ...]_HEARTBEAT_TRANSIENT_ERRORS) extra_headerscKt}t}t}tj}|j s= t j|5|j||||d{} ddd j}tj}| jdkDr3| j}tdt| jdz t}| jdvs | js>#Lkkm$ !!(+ !^^#1,0"/ , 0&&D>>+L!#&&sC(8(81(<>P$QRzz44D B B C2   s8H>FE;)E8*E;.F6C H>H2H0H2H>6H>8E;;FF H-1H(H>AH(H> H(#H>(H--H>0H22H;7H>cr|xstjj|}|std|d||S)zFall back to ``env_var`` for ``value``; raise a clear error if still empty. The ``ANTHROPIC_*`` env vars are the ones the ``ant worker poll --on-work`` command sets on the process it spawns for a claimed work item. z handle_item: u is required — pass it or set )osenvironget ValueError)valuenameenv_varresolveds rE_requirerPs< / w/H =.NwiXYY Oc eZdZdZdddddeeddd d dZd dZd dZddddd dd Z dd Z y)ru#Run a self-hosted environment worker. Composed from the control-plane poller (``client.beta.environments.work.poller``) and the per-session :class:`SessionToolRunner`. For each claimed ``session`` work item it builds the per-session :class:`AgentToolContext` and downloads the session agent's skills, then runs a session tool runner for the session *while* heartbeating the work-item lease in parallel; on exit it force-stops the work item and loops to the next one. A single ``environment_key`` is the worker's only credential: a Bearer-only scoped sub-client is built once per call (one for polling, one for heartbeat / force-stop, and the session tool runner builds its own internally), so every request the worker issues is authenticated by the environment key with the parent client's ``X-Api-Key`` cleared. Async only — :meth:`run` loops forever, so bound it (cancel the task or wrap it in :func:`asyncio.wait_for`) when you want it to stop. Use :meth:`handle_item` if you already hold a claimed work item (e.g. a ``worker poll --on-work`` script handed one to a fresh process) and just want the per-item flow without the poll loop — with no arguments it reads the ``ANTHROPIC_*`` env vars that command sets, so ``environment_id`` (only used by :meth:`run`) isn't needed. Prefer ``client.beta.environments.work.worker(...)`` to build one; the direct constructor below is equivalent. Example:: from anthropic import AsyncAnthropic client = AsyncAnthropic() # Long-running daemon: poll for work, serve each session, loop. await client.beta.environments.work.worker( environment_id=environment_id, environment_key=environment_key, workdir="/workspace", ).run() # Already-claimed item (e.g. inside `ant worker poll --on-work ...`): await client.beta.environments.work.worker(workdir="/workspace").handle_item() # Equivalent, constructing the worker directly: from anthropic.lib.environments import EnvironmentWorker await EnvironmentWorker(client, workdir="/workspace").handle_item() Args: client: The async Anthropic client. environment_id: The self-hosted environment to poll for work. Required by :meth:`run`; not used by :meth:`handle_item`. environment_key: The environment key — the worker's single credential. Used as the Bearer credential on the scoped sub-clients the worker constructs for the control-plane (poll / ack / stop) and session-level (events stream / list / send + heartbeat / force-stop) calls. Required by :meth:`run`; :meth:`handle_item` falls back to it (then to ``ANTHROPIC_ENVIRONMENT_KEY``) when not passed one. tools: Tools to expose to each claimed session. Either a fixed list, or a factory invoked once per session with that session's :class:`AgentToolContext`. Defaults to ``beta_agent_toolset_20260401(env)`` (the standard ``agent_toolset_20260401`` set bound to the per-session context). workdir: Base directory for the per-session :class:`AgentToolContext`. Defaults to :func:`os.getcwd` captured when the worker is constructed (matches the TS worker's ``process.cwd()``-at-construction), so a ``chdir`` between constructing the worker and serving a session does not change where tools resolve paths. unrestricted_paths: Forwarded to the per-session :class:`AgentToolContext`. max_idle: Forwarded to the session tool runner — seconds to keep running after the session goes idle with ``stop_reason`` ``end_turn``. Defaults to :data:`~anthropic.lib.environments.DEFAULT_MAX_IDLE` (60s). ``None`` disables it. worker_id: Optional identifier sent on each poll. Defaults to a unique, hostname-prefixed id. extra_headers: Optional headers passed through per request on every call the worker makes (poll / ack / stop / heartbeat and the session tool runner's event stream / list / send). They are threaded into each call's ``extra_headers=`` and never assigned onto the client, so client state is not mutated. Auth and ``x-stainless-helper`` are supplied by the worker's scoped sub-clients (and the parent client's ``default_headers`` propagate via their ``client.copy()``); a header given here overrides a scoped client's same-named default for that request, so use it for caller passthrough (e.g. trace ids), not auth. NF) r"environment_keytoolsworkdirunrestricted_pathsmax_file_bytesmax_idle worker_idr c ||_||_||_||_|t j n||_||_||_||_ | |_ | |_ y)N) _client_environment_id_environment_key_toolsrHgetcwd_workdir_unrestricted_paths_max_file_bytes _max_idle _worker_id_extra_headers) selfclientr"rSrTrUrVrWrXrYr s rE__init__zEnvironmentWorker.__init__s` - / @G T[ #5 -!#+rQct|jr|j|S|j |jSddlm}||S)Nr)beta_agent_toolset_20260401)callabler^tools.agent_toolsetrj)rfenvrjs rE _tools_forzEnvironmentWorker._tools_forsB DKK ;;s# # ;; ";;  F*3//rQc`K|j}|j}|| tdt|j|d}t |j jj||jd|j23d{}|j||d{$776yw)aPoll the environment and service each claimed session until cancelled. Loops forever; cancel the task (or wrap it in :func:`asyncio.wait_for`) to stop it. Equivalent to claiming work items via ``client.beta.environments.work.poller`` and running the per-item flow for each. Raises: ValueError: if ``environment_id`` / ``environment_key`` were not passed to the constructor. NzWEnvironmentWorker.run: environment_id and environment_key are required to poll for workzenvironments-work-poller auth_tokenhelperF)r"rY auto_stopr ) r\r]rKrr[r beta environmentsr<rdre _handle_item)rfr"rS poll_client work_items rErunzEnvironmentWorker.run$s--//  !_%<vw w4 LL_=W  *    ) ) . .)oo--   @ @)##I? ? ? @ @ s<BB.B,B( B, B."B*#B.(B,*B.,B.)r=r" session_idrSc*Kt|dd}t|dd}t|dd}t|xs |jdd }tj||t jd |  }|j ||d {y 7w)u^Service a single, already-claimed work item without the poll loop. Builds the per-session :class:`AgentToolContext` (workdir from this worker's options) and downloads the session agent's skills, then runs a :class:`SessionToolRunner` for the session *while* heartbeating the work-item lease in parallel, and force-stops the work item on exit (whether the runner finishes normally, raises, or the heartbeat loop signals shutdown). Use this when something else does the claiming — e.g. a ``worker poll --on-work`` script that hands an already-claimed item to a fresh process. ``work_id`` / ``environment_id`` / ``session_id`` fall back to ``ANTHROPIC_WORK_ID`` / ``ANTHROPIC_ENVIRONMENT_ID`` / ``ANTHROPIC_SESSION_ID`` (the env vars that command sets) when not passed; ``environment_key`` resolves in order: the explicit argument, then this worker's own ``environment_key``, then ``ANTHROPIC_ENVIRONMENT_KEY`` — so with no arguments inside that command it just works. Non-session work items are ignored (but still force-stopped so the lease doesn't sit until TTL). Raises: ValueError: if any of ``work_id`` / ``environment_id`` / ``session_id`` / ``environment_key`` is still empty after the fallbacks. r=ANTHROPIC_WORK_ID)rMrNr"ANTHROPIC_ENVIRONMENT_IDrzANTHROPIC_SESSION_IDrSANTHROPIC_ENVIRONMENT_KEYsession)typeid)rr"dataN)rPr]rmodel_constructrrv)rfr=r"rzrSrxs rE handle_itemzEnvironmentWorker.handle_itemCs@7r )rFre cancel_scopecancel)r=r"stop_evrftgwork_ress rE _heartbeatz2EnvironmentWorker._handle_item.._heartbeats] 1-$$++9!(*.*=*= ..0..0s+A#AAAA#AA  A#)rUrVrWrgrz)rTrXrSr T)shield)r"forcer iz-force-stop on exit failed work_id=%s error=%s)r=strr"rr anyio.EventreturnNone) rlrrr[rtrur<rrr,create_task_groupEventr" start_soonr`rarb __aenter__rnrrcrer7rr CancelScope __aexit__r> Exceptionr r5r8)rfrxrSr worker_clientrzr>rrmrTcalls_rDrrs` @@rErvzEnvironmentWorker._handle_itemxs ; 6 LL_=R !%%2277T d"**J..0B >B >B{{}$-<<*3*B*B+/1 1$'1)1 14 j)' MM'+'?'?#'#7#7() >..*** OOC0E 1#5 LL&"'%)^^,;*.*=*= $ % %#+0%%a $yB >`+ %%5 % % % % % ..0 ..00**$7>!mmD$===>>>**$7>!mmD$===>>>CB >B >B >B >B >P""$/ d d"--! '0'?'?"&*&9&9 ( !d%a- "QS\S_S_abcd d d d""$/ d d"--! '0'?'?"&*&9&9 ( !d%a- "QS\S_S_abcd d d ds?P.M3E4M7A8J0H1E H13F9 E"F9E9E&E$ E&E9M H1"F9$E&&E9' F92E53F99F ?FF F9+H19,G%%H1)J?H%HH% J%H. *J1I:I. I" I. % I:.I7 3I::J= MJ  MJ!J J!M$P:M<6K92K53K98M9 L9-L4/M4L99M< PM PO?(O3*6N' N# !N'&O3' O' 0-O" O3"O' 'O3* O?3O< 8O??P)rgrr" str | NonerSrrTzEnvironmentWorkerTools | NonerUzstr | os.PathLike[str] | NonerVboolrWzint | None | NotGivenrXz float | NonerYrr Headers | Nonerr)rmrrzSequence[BetaAnyRunnableTool])rr) r=rr"rrzrrSrrr)rxrrSrrr) __name__ __module__ __qualname____doc__rrrhrnryrrvrQrErrsTt&*&*/315#(09!1 $(,,,# , $ , - ,/,!,.,,,&, ,8 0@D#%)!%&* 3<3<# 3<  3< $ 3< 3rr rrr)rLrrMrrNrrr)4r __future__rrHr)loggingtypingrrrcollections.abcrr,_retryr _pollerr r r _typesrrr_scoped_clientrtypes.beta.environmentsrrtools._beta_session_runnerrrrr[rrlr resources.beta.environments.workr__all__ getLoggerrr5r&r'r(r TimeoutErrorr__annotations__rFrPrrrQrErs%8# 11$ %::22:N )6=  8 9g!'  !8-?,@(K^B_,_#``<]=M;\|;\8\%) = == =  = " = =@ {d{drQ