b\jrZ%SrSSKJr SSKrSSKrSSKrSSKJrJrJ r SSK J r SSK r SSK Jr SS KJrJrJr S S KJrJrJr SS KJr S S KJrJr SSKJrJrJr \(aS SK J!r! SSK"J#r# S SK$J%r% SS/r&\RN"\(5r)Sr*Sr+Sr,\\ \\ S/\ \44r-/\Q\.P7r/S\0S'SS.SSjjr1SSjr2"SS5r3g) 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_headersc# [n[n[n[R"5nUR 5(GdL[ R"U5 URUUUUS9IShvN n SSS5 W Rn[R"5nU RS:a3U Rn[S[U RS- [55nU RS;dU R(d<[R!SU RU R5 UR#5 g[ R,"U5 UR/5IShvN SSS5 UR 5(dGMKggGN !,(df  GN%=f![$an ['U 5(a+[R)SU 5 UR#5 Sn A g[R"5U- U:a+[R)S Xj5 UR#5 Sn A g[R+S U 5 Sn A GNSn A ff=fN!,(df  N=f7f) aKeep the work-item lease alive while a session is being served. ``work`` must be bound to a sub-client authenticated for the environment; this loop adds no auth of its own. Sets ``stop`` when the control plane reports the work is ``stopping`` / ``stopped``, when the lease is no longer extended, on a permanent heartbeat failure, or when transient failures have run long enough that the lease must be assumed lost (so two runners don't end up serving the same work). )environment_idexpected_last_heartbeatr Nrg?r)stoppingstoppedz5heartbeat signals shutdown state=%s lease_extended=%sz$permanent heartbeat failure error=%sz=lease assumed lost: no successful heartbeat in %.0fs error=%sz$transient heartbeat failure error=%s)_HEARTBEAT_DEFAULT_HEARTBEAT_TTL_DEFAULT_NO_HEARTBEAT_SENTINELtime monotonicis_setanyio fail_after heartbeatlast_heartbeat ttl_secondsmaxminstatelease_extendedloginfosetrr errorwarning move_on_afterwait) workwork_idr"stopr intervalttllast last_successrespes X/var/www/website/venv/lib/python3.13/site-packages/anthropic/lib/environments/_worker.py_heartbeat_looprFZs""H C !D>>#Lkkmm$ !!(+!^^#1,0"/ ,,0&&D>>+L!#&&sC(8(81(<>P$QRzz44D B B C2 + *s>I%F"F-F .F2F":CI%I&I'I+I% I% F FF"" I,6I "I%'AI )I%.I I% II%I I"I%cU=(d [RRU5nU(d[SUSU35eU$)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 \rSrSrSrSSSSS\\SSS. S SjjrSSjrSSjr SSSSS .SS jjr SS jr S r g)ruRun 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 XlX lX0lX@lUc[R "5OUUlX`lXplXl Xl Xl g)N) _client_environment_id_environment_key_toolsrHgetcwd_workdir_unrestricted_paths_max_file_bytes _max_idle _worker_id_extra_headers) selfclientr"rTrUrVrWrXrYrZr s rE__init__EnvironmentWorker.__init__sN - / @G T[ #5 -!#+rQc[UR5(aURU5$URb UR$SSKJn U"U5$)Nr)beta_agent_toolset_20260401)callabler_tools.agent_toolsetrl)rgenvrls rE _tools_forEnvironmentWorker._tools_forsE DKK ;;s# # ;; ";;  F*3//rQcX# URnURnUbUc [S5e[URUSS9n[ UR RRUURSURS9ShvN nURXB5IShvN M$NN g7f)a~Poll 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"rZ auto_stopr ) r]r^rKrr\r beta environmentsr<rerf _handle_item)rgr"rT poll_client work_items rErunEnvironmentWorker.run$s--//  !_%<vw w4 LL_=W  *    ) ) . .)oo--   @)##I? ? ? @ @ s<A>B*B(B$B(B*B&B*$B(&B*(B*)r=r" session_idrTc # [USSS9n[USSS9n[USSS9n[U=(d URSS S9n[R"UU[R"S US 9S 9nUR XT5IS hvN g N7f)uService 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_IDr~ANTHROPIC_SESSION_IDrTANTHROPIC_ENVIRONMENT_KEYsession)typeid)rr"dataN)rPr^rmodel_constructrry)rgr=r"r~rTr{s rE handle_itemEnvironmentWorker.handle_itemCs@7# [TUUUTRS9IShvN TRR5 gN!TRR5 f=f7f)N)r=r"r>r )rFrf cancel_scopecancel)r=r"stop_evrgtgwork_ress rE _heartbeat2EnvironmentWorker._handle_item.._heartbeats\ 1-$$++9!(*.*=*= ..0..0s)A A?AA AAA )rVrWrXrhr~)rUrYrTr T)shield)r"forcer iz-force-stop on exit failed work_id=%s error=%s)r=strr"rr anyio.EventreturnNone) rnrrr\rwrxr<rrr,create_task_groupEventr" start_soonrarbrc __aenter__rprrdrfr7rr CancelScope __aexit__r> Exceptionr r5r8)rgr{rTr worker_clientr~r>rrorUcalls_rDrrs` @@rEryEnvironmentWorker._handle_itemxs] ; 6 LL_=R !%%2277T d"**J..00B{{}$-<<*3*B*B+/1 1$'1)1 114 j)' MM'+'?'?#'#7#7() >..*** OOC0E 1#5 LL&"'%)^^,;*.*=*= $$#+0%a $y1`+$%5$$$$$$ ..0 ..00**$7!mmD$===877**$7!mmD$===877C100000P""$/ d"--! '0'?'?"&*&9&9 ( !d%a-- "QS\S_S_abcd0//""$/ d"--! '0'?'?"&*&9&9 ( !d%a-- "QS\S_S_abcd0//s P P PP) r\r]r^rfrcrdr_rbrare)rhrr" str | NonerTrrUzEnvironmentWorkerTools | NonerVzstr | os.PathLike[str] | NonerWboolrXzint | None | NotGivenrYz float | NonerZrr Headers | Nonerr)rorrzSequence[BetaAnyRunnableTool])rr) r=rr"rr~rrTrrr)r{rrTrrr) __name__ __module__ __qualname____firstlineno____doc__rrrirpr|rry__static_attributes__rQrErrsTt&*&*/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\rrnr resources.beta.environments.workr__all__ getLoggerrr5r&r'r(r TimeoutErrorr__annotations__rFrPrrrQrErs#8# 11$ %::22:N )6=  8 9 !'  !8-?,@(K^B_,_#``<]=M;\|;\8\%) = == =  = " = =@ {d{drQ