߲jCFdZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ejdZdZd Zd ZeeeehZd eefd Zd eded dfdZdefdZdedefdZdefdZdeded dfdZded dfdZGddZy)zInterrupt / steer / redirect control surface for ``AIAgent``. Soft/hard interrupt requests, tool-thread interrupt propagation, pending steer/redirect queues. Extracted from ``run_agent.py``; every method resolves through ``AIAgent``'s MRO unchanged. N)Optional)request_hard_interrupt) request_yield) set_interrupt run_agentzexplicit stop requestedzuser sent a new messagezuser interruptreturnct|dd}|r|tvryt|jj ddS)zWSlug of the system producer behind the pending interrupt, or ``None`` for a human stop._tool_interrupt_reasonN _)getattrUSER_INTERRUPT_REASONSstrstripreplace)agentreasons FG~]"4;0FM$% 5  '& 5 LLtL 4 5sA A+*A+attrcLt||d}|tjS|S)zY``with`` the lock stored at ``attr`` when present; __init__-less test stubs run unlocked.N)r contextlib nullcontext)rr&locks r_ic_lockr+6s( 5$ %D'+|: ! ! #==r lock_attrslotcNt||d t||dSt||S)aRead the pending-text ``slot`` guarded by ``lock_attr``. An initialized agent always has both attributes, so under the lock the slot is read directly and a missing one fails loud (a real bug); only ``__init__``-less test stubs (no lock) get the ``getattr`` fallback.N)r )rr,r-s r_ic_slotr/<s/ui&.udD)) 5$ rnamecrt|dddk7rytt|dd|d}t|r|SdS)zLCodex app-server owns its model/tool loop; return its ``name`` hook or None.api_modeNcodex_app_server_codex_session)r r )rr0methods r_ic_codex_methodr6EsAuj$'+== WU$4d;T4 HFf%6/4/rrct|dd}t|r ||yy#t$rtj |dYywxYw)zXShut the registered in-flight request's sockets (cron turns register their client here)._active_request_abortNTr)r r r!r"r#)rrraborts r_ic_abort_active_requestr:MsJ E2D 9E 5 &M 5 LLtL 4 5s$ AAactivec t|dd}t|dd}||y|5t|}dddD]} t||fi|y#1swYxYw#t$rY+wxYw)a-Fan the tool interrupt bit out to concurrent-tool worker tids. ``is_interrupted()`` inside a tool only sees its own tid, so without this a hung concurrent tool runs to its own timeout (and a stale bit could survive a turn boundary onto a recycled tid). getattr covers __init__-less stubs._tool_worker_threadsN_tool_worker_threads_lock)r list_set_interruptr!)rr;kwtracker tracker_lock worker_tidstids r_ic_signal_tool_workersrFWs e3T:G5"=tDL,. $7m $  63 -" -$$    s A  A A A$#A$c eZdZdZ ddddddeededeedeed ef d Zddd deedeed dfd Z ddd deded efdZ ded efdZ ded efdZ d efdZ d eefdZd eefdZy)InterruptControlMixinzYinterrupt()/hard_interrupt()/clear_interrupt()/steer()/redirect() (see module docstring).NF) hard_cancel tool_reasonrequire_generationmessagerIrJrKrc |:j5tdd|k7r dddy|_dddr |xstn rtnt d fd }fd}t d5t|dd ||nIj5td d|k7r ddddddyd_|dddt|dd d_dddtd }| |tddj tdj d_nd_t#d j$5t'j(}dddD]%} rt+|  n| j-'j.s/t1drt3dkDr ddddn rddndzy#1swYxYw#1swY-xYw#1swYxYw#t$rtjddY(wxYw#1swYxYw#t$r } tjd| Yd} ~ d} ~ wwxYw)uRequest the agent to interrupt its current tool-calling loop (call from another thread). ``hard_cancel``: explicit stop; compression may honor it even while ordinary interrupts are masked. ``tool_reason``: trusted fixed category safe for tool output. ``require_generation``: activity- generation claim — published only if the turn's generation still matches at the final mutation edge; returns False if the turn resumed meanwhile. N"_turn_liveness_activity_generationrFcd___tj drdndr t ddnd}||j yy)NTzInterrupt requested (%s): %shardsoft_hard_interrupt_requested)_interrupt_requested_interrupt_messager r"infor set) _hard_eventrIrLselftool_interrupt_reasons r_publish_interrupt_statezAInterruptControlMixin.interrupt.._publish_interrupt_states[(,D %&-D #*?D ' KK6+SY[p qNY'$(CTJ_cK&!'rc@rtjdSdS)N _active_compression_commit_fence)varsget)rIrXsr_fencez/InterruptControlMixin.interrupt.._fencesIT4:>>"DE ^Z^ ^r_pending_redirect_lockTz)Compression hard-cancel fence wait failed)rr_turn_liveness_abort_claimz.Compression hard-cancel fence admission failedrequest_interruptz)Failed to interrupt Codex app-server turnrinterrupt_abortz%Failed to abort active inline request)rrJz0Failed to propagate interrupt to child agent: %su ⚡ Interrupt requested(z: 'z...'')rN)_liveness_activity_lockr ra_REASON_HARD_STOP_REASON_NEW_MESSAGE_REASON_USER_INTERRUPTr+r%_pending_redirectr6r!r"r#r:_execution_thread_idr@ _interrupt_thread_signal_pendingrF_active_children_lockr?_active_childrenr interrupt quiet_modeprintlen) rXrLrIrJrKrZr__request_interrupt children_copychilderYs ``` @rrqzInterruptControlMixin.interruptms  )--/ E4!EqIM__  E E3E/ E3>[ --)0%6L   " " _d4 5 * ';f "))* 113/t%A4HL^^$/ * *7;D3,. / (=H>I  I6I11I6rdc6tj||d|y)aExplicit stop preserving the ``interrupt()`` ABI (frontends feature-detect this and fall back to legacy ``interrupt()`` for third-party agents). Bypasses dynamic dispatch: legacy subclasses may override interrupt(message=None) without hard_cancel.T)rIrJN)rHrq)rXrLrJs rhard_interruptz$InterruptControlMixin.hard_interrupts ''g4U`'ar)preserve_redirectrIr{ct|d5|rt|dds dddyd|_dx|_|_t |dt jj|sd|_ dddd|_ |jtd|jt|d|rt|d5d|_dddyy#1swY^xYw#1swYyxYw)uClear the interrupt request and per-thread tool signal. ``preserve_redirect`` is only for the conversation loop rebuilding the same logical turn after cancelling a model request. ``hard_cancel`` also drops an unconsumed pending steer: the aborted turn's next tool iteration will no longer happen, and re-injecting the note into the post-stop turn would surprise the user. Every other caller (redirect rebuild, error recovery, turn-boundary hygiene) continues this session, so the already-accepted steer must survive: it stays buffered for the existing drains — the pre-API inject, the post-batch append, or the finalizer's leftover handoff — instead of silently vanishing after the surface was told it was delivered.r`rlNFrR_pending_steer_lockT)r+r/rSrTr r threadingEventclearrlrnrmr@rF_pending_steer)rXr{rIs rclear_interruptz%InterruptControlMixin.clear_interruptsd4 5 . $8PRe)f . .).D %DH HD #d&A D5y7H I O O Q$)-& .16-  $ $ 0 5$";"; <e, $ 56 +&*# +% . .  +sCA C=CCC$textc|r|jsy|j}t|d5t|dd}|r|dz|zn||_dddy#1swYyxYw)zQueue user text for delivery as its own user row after the current tool batch finishes (no interrupt); multiple calls concatenate with newlines. Returns False for empty text.Fr}r NT)rr+r/r)rXrcleanedexistings rsteerzInterruptControlMixin.steersj4::<**, d1 2 W&;=MNHAI8d?W#t|d5|jr dddy ddd t ||St|ddr[|j|}|rFt|d d}t|d d}|*|(|5t|}dddD] }t||St|d d} t|d5| | js dddyt|dd } |jr | s dddy| r| d |n||_d|_d|_dddt|dd} | t!d| d|_nd|_t%|ddy#1swY=xYw#t $rt jddYywxYw#1swY xYw#1swYxYw)aRedirect the active turn without converting it into a new task: during a model request only that request is cancelled (completed messages kept, partial reasoning becomes assistant context, the correction is appended as a real user message, the loop retries); during tool execution it degrades to ``steer()``; Codex app-server uses native ``turn/steer``. False when no live turn / empty text.F request_steerNr`z"Codex app-server turn/steer failedTr_executing_toolsr=r>_model_request_activerlz [Additional user correction] rmredirect_abortz$Failed to abort request for redirect)rr6r+rSrr!r"r#r rr?_request_yieldis_setr/rlrTr@rnr:) rXrr _native_steeracceptedrBrCrDrE _model_activerrms rredirectzInterruptControlMixin.redirects 4::<**,(?  $$ 89 !,,  ! !, ! M'233 4+U 3zz'*H!$(>E&t-H$O &<+C%4&*7m 4*,&s+,O&=tD d4 5 +$M,@,@,B + + &>@STH(( + +MU8*>wiHZa  ")-D %&*D # + 't-CTJ  + 4!5 649D 148D 1 '79_`] ! !   AD Q 44 + +sAFF0 G1GG3GF GGGGcrt|d5tt|ddcdddS#1swYyxYw)z@Return whether an active-turn redirect is waiting to be applied.r`rlN)r+rr/)rXs r_has_pending_redirectz+InterruptControlMixin._has_pending_redirect:s9 d4 5 W'?ATUV W W Ws-6crt|d5t|dd}d|_ddd|S#1swYSxYw)z5Return and clear pending active-turn correction text.r`rlN)r+r/rlrXrs r_drain_pending_redirectz-InterruptControlMixin._drain_pending_redirect?sC d4 5 *D":rs 9;;   ; ' ./)"$57JLb#cd1x}15$5S5UY5&>#>  s # 0#05C5c5d54$&aar