+ kHj)~a0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIH t H t ^RI H t ^RI Ht]P!]4t^ t^2t^t^tRtRt!RR]4t!R R ]4t]P6!R ]P84tR R ltRRltRRlt RRlt!RRlt"!RR4t#Rs$R]%R&RRlt&RRlt'R#)uSignal attachment rate-limit scheduler: process-wide token-bucket simulator mirroring the per-account attachment rate limit signal-cli/Signal-Server enforce. Producers (``SignalAdapter.send_multiple_images`` and the ``send_message`` tool's Signal path) call ``acquire(n)`` before an attachment send; on a 429 they call ``feedback(retry_after, n)`` so the model recalibrates from the server's authoritative hint. Concurrent calls serialize through an ``asyncio.Lock`` — FIFO fairness across sessions sharing one daemon.) annotationsN)AnyOptional)t)parse_retry_after_secondsg$@c6a]tRt^tRtRRV3RllltRtV;t#)SignalRateLimitErroruRaised by ``SignalAdapter._rpc`` for rate-limit responses when ``raise_on_rate_limit=True``. ``retry_after`` is the server's per-token Retry-After in seconds (signal-cli ≥ v0.14.3) or None.c$V^8dQhRRRRRR/#)messagestr retry_afterOptional[float]returnNone)formats"O/home/ubuntu/.hermes/hermes-agent/plugins/platforms/signal/signal_rate_limit.py __annotate__!SignalRateLimitError.__annotate__ s!'''/'T'c 2<\SV`V4W nR#N)super__init__r )selfr r __class__s&&&rrSignalRateLimitError.__init__ s !&r)r r)__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__ __classcell__)rs@rrrsj'''rrc]tRt^%tRtR#)SignalSchedulerErrorrN)rrr r!r#rrrr&r&%srr&z$Retry after (\d+(?:\.\d+)?)\s*secondc V^8dQhRRRR/#)r errrrr r)rs"rrr.sNNNNrcz\V\4'd\VPRR44#\V4#)r ) isinstancedictr get)r(s&r_error_messager..s-*4S$*?*?3swwy"% &MSXMrc V^8dQhRRRR/#)r r(rrrr)rs"rrr2s H Hc Ho Hrch\V\4'dVPR4;'g/PR4;'g/PR4;'g.pVUu.uFNp\V\4'gKVPR4'gK4\VPR44NKP ppVUu.uF qDfKVNK up;p'd \ V4#\ P \V44pV'd\VP^44#R#uupiuupi)uPer-token Retry-After from a signal-cli rate-limit error, or None. Sources, in order: ``error.data.response.results[*].retryAfterSeconds`` (signal-cli ≥ v0.14.3), then "Retry after N seconds" parsed from the message (RetryLaterException wrapped as AttachmentInvalidException).dataresponseresultsretryAfterSecondsN) r+r,r-rmax_RETRY_AFTER_REsearchr.group)r(r3r candidatescmatchs& r_extract_retry_after_secondsr=2s#tGGFO))r..z:@@bEEiPVVTVU\MU\PQ#At,L127J1KL/6I0JKU\ M%/AZ!!ZA A: Az? "  " ">##6 7E8= $U[[^ 4G4G MAs(D*D*D*D/ D/c V^8dQhRRRR/#)r r(rrboolr)rs"rrr@srrSrTrrc,a\V\4'dVPR4\8XdR#\ V4pVP 4oRV9;'g;\ ;QJdV3RlR4F 'gK R# R#!V3RlR44#)uTrue if a signal-cli RPC error reflects a rate-limit failure: the typed ``RATELIMIT_ERROR`` code (≥ v0.14.3), legacy ``[429]`` / ``RateLimitException`` substrings, or libsignal-net's ``RetryLaterException`` / "Retry after N seconds" leaked through AttachmentInvalidException.codeTz[429]c3,<"TF qS9xK R#5irr).0s msg_lowers& r ._is_signal_rate_limit_error..Hs$q=p)^=psF) ratelimitretrylaterexceptionz retry after)r+r,r-SIGNAL_RPC_ERROR_RATELIMITr.lowerany)r(r rEs& @r_is_signal_rate_limit_errorrM@sr#t4N!NS!G I g  q q$q=p$qqq$q=p$q!qqrc V^8dQhRRRR/#)r secondsfloatrr r)rs"rrrKsKK%KCKrc \RV4pV^Z8d\R\V4R7#\R\^\V^<, 44R7#)z9Human-friendly wait label for user-facing pacing notices.zplatform.signal.wait_seconds)countzplatform.signal.wait_minutes)r5rround)rOrDs& r _format_waitrUKsk CA@AB1 +58 <KANltwxy|ABCFHBH|IuJMKKrc V^8dQhRRRR/#)r num_attachmentsintrrPr)rs"rrrQsNN#N%Nrc:V^8:dR#\RRV,4#)zHTTP timeout for a Signal ``send`` RPC: signal-cli uploads attachments serially inside the call, so the default 30s truncates large batches mid-upload (phantom failure). 5s/attachment, 60s floor.g>@gN@g@)r5)rWs&r_signal_send_timeoutrZQs"#a'4MSs_7L-MMrc]tRt^WtRt]!]4]!]43RRlltRRRllt RRlt R R lt R R lt R Rlt RRltRRltRtR#)SignalAttachmentSchedulerurProcess-wide token-bucket simulator for Signal attachment sends: up to ``capacity`` tokens (default 50 = Signal's server bucket), one per attachment, refilling at ``refill_rate``/s (calibrated from the server's per-token Retry-After once a 429 has been observed; default 1 token / 4s). ``acquire(n)`` calls serialize through an ``asyncio.Lock`` — FIFO across sessions.c$V^8dQhRRRRRR/#)r capacityrPdefault_retry_afterrrr)rs"rr&SignalAttachmentScheduler.__annotate__]s#$$$&+$_c$rc \V4Vn\V4VnR\V4, Vn\P !4Vn\P!4Vn R#)?N) rPr^tokens refill_ratetime monotonic last_refillasyncioLock_lock)rr^r_s&&&rr"SignalAttachmentScheduler.__init__]sGh Ho ':!;;>>+\\^ rNc V^8dQhRRRR/#)r nowrrrPr)rs"rrr`es_rc $Vf\P!4MTVP, pV^8dSVPVP8d8\ VPVPW P ,,4#VP#)z@Tokens the bucket would hold at ``now``, without mutating state.)rerfrgrcr^minrd)rrmelapseds&& r_projected_tokens+SignalAttachmentScheduler._projected_tokensesb'*{4>>#t?O?OO Q;4;;6t}}dkkG>N>N4N&NO O{{rcV^8dQhRR/#r rrr)rs"rrr`lsrc h\P!4pVPV4VnWnR#r)rerfrqrcrg)rrms& r_refill!SignalAttachmentScheduler._refillls&nn,,S1 rc V^8dQhRRRR/#r nrXrrPr)rs"rrr`qsCCsCuCrc dWP4, pV^8:dR#W P, #)uSeconds until ``n`` tokens would be available (lock-free, informational — decides whether to emit a pacing notice *before* a possibly-blocking ``acquire``; races vs. concurrent acquires are benign).rR)rqrd)rrzdeficits&& r estimate_wait'SignalAttachmentScheduler.estimate_waitqs/,,..lsB2B2B(BBrc V^8dQhRRRR/#ryr)rs"rrr`ws  s u rc "V^8:dR#WP8d\RV RVP R24hRRr2VP;_uu_4GRjxL VP4VPV8dEV'dV^8d"\ P RWPV4TuuRRR4GRjxL #WP, pRRR4GRjxL XVP, pV'dA\ PRWQVPW@PR VP, 4R p\P!V4GRjxL W%, pEK)ELLL +GRjxL 'giL;iL25i) uBlock until at least ``n`` tokens are available; return the seconds slept. Does **not** deduct tokens — the bucket is a read-only model of server-side capacity; call ``report_rpc_duration()`` after the RPC to sync. The lock is released during ``asyncio.sleep`` so other callers interleave, and the loop re-checks after each sleep in case the deadline was pessimistic. Signal's server is ground truth and will 429 (→ requeue) if the model drifts.rRz'Signal scheduler was called requesting z tokens (max is )TNzNSignal scheduler: tokens sufficient for %d (remaining=%.1f, total_slept=%.1fs)ukSignal scheduler: pausing %.1fs for %d tokens (available=%.1f, deficit=%.1f, refill=%.4f/s ≈ %.1fs/token)rbF) r^r&rjrvrcloggerdebugrdinforhsleep)rrz total_slept first_passr|waits&& racquire!SignalAttachmentScheduler.acquirews& 6 }} &)PQRPSScdhdqdqcrrs'tu u"%tZzzzz ;;!#%q %u%& [B& "zzkk/"zT---D =>Bt{{T[]m]m$"2"224# --% % %  K"zzz &sAF E$F )E+)E++ F 8E'9F >E+ F E)F ;AF FF 'F )F +F 1E42 F =F ? F c$V^8dQhRRRRRR/#)r rpc_durationrP n_attachmentsrXrrr)rs"rrr`s" % %e %C %TX %rc "V^8:dR#VP;_uu_4GRjxL VPp\RV\V4, 4Vn\P !4VnRRR4GRjxL \PV^ 8dV^8d\PM\PRW!XVPVVP4R#LLc +GRjxL 'giLz;i5i)a"Deduct ``n_attachments`` tokens for a completed send RPC. No refill is credited for the upload window: Signal's server checks the bucket at RPC start and resumes refill only after the response, so crediting it causes cumulative drift that eventually triggers 429s. Advances ``last_refill``.NrRuSignal scheduler: RPC for %d att took %.1fs — tokens %.1f → %.1f (deducted=%d, no upload refill credited, refill=%.4fs⁻¹)) rjrcr5rPrerfrgrlogloggingINFODEBUGrd)rrr token_befores&&& rreport_rpc_duration-SignalAttachmentScheduler.report_rpc_durations A  ::::;;Lc<% 2F#FGDK#~~/D :  <"#49J7<>+rcV^8dQhRR/#)r rr,r)rs"rrr`sxxtxrc  R\VP4^4R\VP4R\VP^4RVP^8d\RVP, ^4/#\ R4/#)z\Current scheduler state for diagnostic logging (read-only, doesn't advance ``last_refill``).rcr^rdrefill_seconds_per_tokenrbinf)rTrqrXr^rdrP)rs&rstateSignalAttachmentScheduler.states}% 6 6 8!rsp # 7   8 $!#$&!()%!"'+$'9' 9 **DbmmTN HrK N ZxZxz37 /6r